From patchwork Fri Apr 29 01:04:04 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chris Gregory X-Patchwork-Id: 616558 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3qwwV92Q4Rz9t50 for ; Fri, 29 Apr 2016 11:05:13 +1000 (AEST) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b=t3tWLIBL; dkim-atps=neutral DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :mime-version:from:date:message-id:subject:to:content-type; q= dns; s=default; b=EJCll9NAzEKJRMrbAPjTRUIc3hp0WRvYFlj7zaIcG1hH8u 2tS5d6G38EMpt2/9zrXFx960eKc6aeAcp6mp6oxd23vcJOSlKMABVsDt8L535DFX eY7ygWCxzO6pls2MRTQDXdM1yj8bf25utG/OP0gXVUccoBW/R3Zs1PWjuWh18= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :mime-version:from:date:message-id:subject:to:content-type; s= default; bh=k9eIOt/et1TYOwmr8cBhSMDtFhI=; b=t3tWLIBLWVVQkDz47f40 KvyK5qzvNDNcnttKNV/g9J768tMwySNoXwzoFdQUU1lGMOBGDRRMbbSVxvkmR0AD vKdC30Xb/jiYGwELLXAsiTX1MCTCVWlsodKLC0cViWpamDftaZnL02wpaUTCP0+D 2lN+igk+0/k9vEtqONgR2CE= Received: (qmail 73997 invoked by alias); 29 Apr 2016 01:05:00 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 73976 invoked by uid 89); 29 Apr 2016 01:04:58 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.8 required=5.0 tests=AWL, BAYES_50, FILL_THIS_FORM, FREEMAIL_FROM, KAM_ASCII_DIVIDERS, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=no version=3.3.2 spammy=73, 7, ios, edwards, Edwards X-Spam-User: qpsmtpd, 2 recipients X-HELO: mail-io0-f181.google.com Received: from mail-io0-f181.google.com (HELO mail-io0-f181.google.com) (209.85.223.181) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Fri, 29 Apr 2016 01:04:46 +0000 Received: by mail-io0-f181.google.com with SMTP id f89so94132987ioi.0; Thu, 28 Apr 2016 18:04:45 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:from:date:message-id:subject:to; bh=xovqUk5fe15ktkYWPYNA2Rdz5+GfSXwxxkZH1paAdGE=; b=HBeTZCk3bi5s2TNvybwdmxHqPQRMyILiR6eatHOECY8SxKB/EPadn7Dtknc+k0ooHb dY4kPvgYIEDkUOP0lwkPoJuB5DNfI4VB34gRsao+xv+FGu76woPST1qIWCrjZZ9is2VU YhPLhQhoTtXJ2nAZDWIChozGhIeWUcgiXhGDI4C+xxoiqvTawbBYxtGDLMJb8j4zAmfx f1zPcggNrhBA927MOjMRma6fPAQVB+hUeEyNzs5cDk3XTGBvflr9xDaIoDip3l2HhsGi EC1sq5FL5ThBLjkR1UdtdH/Lo3aSkSK4ntKTsB+8okGFpPnQNvUyKjbGwdTEvA6hin// Frmw== X-Gm-Message-State: AOPr4FXnh7JxaIXxwZ5bbr/2zMZ3gkfOCsiMB1RNsNZ6CpR5ztjBWO9DsBwvuqYWyMFAyrgyhUaZshyKN5vhUg== X-Received: by 10.107.62.197 with SMTP id l188mr9517047ioa.185.1461891883776; Thu, 28 Apr 2016 18:04:43 -0700 (PDT) MIME-Version: 1.0 Received: by 10.50.70.162 with HTTP; Thu, 28 Apr 2016 18:04:04 -0700 (PDT) From: Chris Gregory Date: Thu, 28 Apr 2016 18:04:04 -0700 Message-ID: Subject: [patch] Remove trailing whitespaces from testsuite/util To: gcc-patches , "libstdc++" I had to break this patch up into multiple edits. Here is the one for ``libstdc++-v3/testsuite/util''. Cheers, Chris Gregory! Index: libstdc++-v3/testsuite/util/common_type/assoc/common_type.hpp =================================================================== --- libstdc++-v3/testsuite/util/common_type/assoc/common_type.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/common_type/assoc/common_type.hpp (working copy) @@ -537,7 +537,7 @@ namespace __gnu_pbds __gnu_pbds::null_type, Eq_Fn, Comb_Hash_Fn, - typename one_resize_policy_selector::type, + typename one_resize_policy_selector::type, false, _Alloc> type; }; Index: libstdc++-v3/testsuite/util/common_type/assoc/detail/ds_string_form.hpp =================================================================== --- libstdc++-v3/testsuite/util/common_type/assoc/detail/ds_string_form.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/common_type/assoc/detail/ds_string_form.hpp (working copy) @@ -113,8 +113,8 @@ namespace __gnu_pbds const std::string store_hash_desc = store_hash_string_form::desc(); - - return make_xml_tag("type", "value", "gp_hash_table", + + return make_xml_tag("type", "value", "gp_hash_table", comb_probe_fn_desc + probe_fn_desc + resize_policy_desc + store_hash_desc); } }; @@ -146,7 +146,7 @@ namespace __gnu_pbds }; template - struct ds_string_form + struct ds_string_form : private tree_ds_string_form { private: @@ -163,7 +163,7 @@ namespace __gnu_pbds }; template - struct ds_string_form + struct ds_string_form : private tree_ds_string_form { private: @@ -180,7 +180,7 @@ namespace __gnu_pbds }; template - struct ds_string_form + struct ds_string_form : private tree_ds_string_form { private: Index: libstdc++-v3/testsuite/util/common_type/assoc/detail/list_update_policy_string_form.hpp =================================================================== --- libstdc++-v3/testsuite/util/common_type/assoc/detail/list_update_policy_string_form.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/common_type/assoc/detail/list_update_policy_string_form.hpp (working copy) @@ -63,7 +63,7 @@ namespace __gnu_pbds static std::string desc() { - return make_xml_tag("Update_Policy", "value", + return make_xml_tag("Update_Policy", "value", "lu_move_to_front_policy"); } }; @@ -82,7 +82,7 @@ namespace __gnu_pbds static std::string desc() { - return (make_xml_tag("Update_Policy", "value", "lu_counter_policy", + return (make_xml_tag("Update_Policy", "value", "lu_counter_policy", "Max_Count", Max_Count)); } }; Index: libstdc++-v3/testsuite/util/common_type/assoc/string_form.hpp =================================================================== --- libstdc++-v3/testsuite/util/common_type/assoc/string_form.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/common_type/assoc/string_form.hpp (working copy) @@ -157,19 +157,19 @@ namespace __gnu_pbds { }; template - struct tag_select_string_form + struct tag_select_string_form : public native_string_form { }; template - struct tag_select_string_form + struct tag_select_string_form : public native_string_form { }; } // namespace detail template - struct string_form - : public detail::tag_select_string_form { }; } // namespace test Index: libstdc++-v3/testsuite/util/common_type/assoc/template_policy.hpp =================================================================== --- libstdc++-v3/testsuite/util/common_type/assoc/template_policy.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/common_type/assoc/template_policy.hpp (working copy) @@ -47,7 +47,7 @@ namespace __gnu_pbds namespace test { template - struct direct_mask_range_hashing_t_ + struct direct_mask_range_hashing_t_ : public __gnu_pbds::direct_mask_range_hashing { typedef typename _Alloc::size_type size_type; @@ -55,7 +55,7 @@ namespace __gnu_pbds }; template - struct direct_mod_range_hashing_t_ + struct direct_mod_range_hashing_t_ : public __gnu_pbds::direct_mod_range_hashing { typedef typename _Alloc::size_type size_type; @@ -68,7 +68,7 @@ namespace __gnu_pbds typename _Alloc::size_type Max_Load_Nom, typename _Alloc::size_type Max_Load_Denom, bool External_Access> - struct hash_load_check_resize_trigger_t_ + struct hash_load_check_resize_trigger_t_ : public __gnu_pbds::hash_load_check_resize_trigger { @@ -76,7 +76,7 @@ namespace __gnu_pbds typedef __gnu_pbds::hash_load_check_resize_trigger base_type; inline - hash_load_check_resize_trigger_t_() + hash_load_check_resize_trigger_t_() : base_type(static_cast(Min_Load_Nom) / static_cast(Min_Load_Denom), static_cast(Max_Load_Nom) / static_cast(Max_Load_Denom)) { } @@ -91,7 +91,7 @@ namespace __gnu_pbds typename _Alloc::size_type Load_Nom, typename _Alloc::size_type Load_Denom, bool External_Access> - struct cc_hash_max_collision_check_resize_trigger_t_ + struct cc_hash_max_collision_check_resize_trigger_t_ : public __gnu_pbds::cc_hash_max_collision_check_resize_trigger { @@ -99,7 +99,7 @@ namespace __gnu_pbds typedef __gnu_pbds::cc_hash_max_collision_check_resize_trigger base_type; inline - cc_hash_max_collision_check_resize_trigger_t_() + cc_hash_max_collision_check_resize_trigger_t_() : base_type(static_cast(Load_Nom) / static_cast(Load_Denom)) { } @@ -114,32 +114,32 @@ namespace __gnu_pbds { }; template - struct hash_exponential_size_policy_t_ + struct hash_exponential_size_policy_t_ : public __gnu_pbds::hash_exponential_size_policy { }; template - struct linear_probe_fn_t_ + struct linear_probe_fn_t_ : public __gnu_pbds::linear_probe_fn { }; template - struct quadratic_probe_fn_t_ + struct quadratic_probe_fn_t_ : public __gnu_pbds::quadratic_probe_fn { }; template - struct lu_counter_policy_t_ + struct lu_counter_policy_t_ : public __gnu_pbds::lu_counter_policy { typedef __gnu_pbds::lu_counter_policy base_type; }; - struct lu_move_to_front_policy_t_ + struct lu_move_to_front_policy_t_ : public __gnu_pbds::lu_move_to_front_policy<> { }; } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/common_type/priority_queue/string_form.hpp =================================================================== --- libstdc++-v3/testsuite/util/common_type/priority_queue/string_form.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/common_type/priority_queue/string_form.hpp (working copy) @@ -83,13 +83,13 @@ namespace __gnu_pbds { }; template - struct tag_select_string_form + struct tag_select_string_form : public native_string_form { }; } // namespace detail template - struct string_form + struct string_form : public detail::tag_select_string_form { }; } // namespace test Index: libstdc++-v3/testsuite/util/debug/checks.h =================================================================== --- libstdc++-v3/testsuite/util/debug/checks.h (revision 235613) +++ libstdc++-v3/testsuite/util/debug/checks.h (working copy) @@ -59,7 +59,7 @@ namespace __gnu_test typedef _Tp1 first_type; typedef _Tp2 second_type; typedef std::pair<_Tp1, _Tp2> pair_type; - + pair_type build() { static first_type _S_1; @@ -181,7 +181,7 @@ namespace __gnu_test val_type *last = first + 2; cont_type c(last, first); // Expected failure - } + } // Check that invalid range of debug random iterators is detected template Index: libstdc++-v3/testsuite/util/debug/unordered_checks.h =================================================================== --- libstdc++-v3/testsuite/util/debug/unordered_checks.h (revision 235613) +++ libstdc++-v3/testsuite/util/debug/unordered_checks.h (working copy) @@ -51,7 +51,7 @@ namespace __gnu_test typedef _Tp1 first_type; typedef _Tp2 second_type; typedef std::pair<_Tp1, _Tp2> pair_type; - + pair_type build() { static first_type _S_1; Index: libstdc++-v3/testsuite/util/exception/safety.h =================================================================== --- libstdc++-v3/testsuite/util/exception/safety.h (revision 235613) +++ libstdc++-v3/testsuite/util/exception/safety.h (working copy) @@ -612,7 +612,7 @@ namespace __gnu_test template::has_push_pop::value - && traits<_Tp>::has_emplace::value + && traits<_Tp>::has_emplace::value && traits<_Tp>::is_reversible::value> struct emplace_back { @@ -1317,7 +1317,7 @@ namespace __gnu_test functions.push_back(function_type(iops)); typename base_type::const_iterator_ops ciops; functions.push_back(function_type(ciops)); - + typename base_type::erase_point erasep; functions.push_back(function_type(erasep)); typename base_type::erase_range eraser; @@ -1352,7 +1352,7 @@ namespace __gnu_test typename base_type::move_assign_operator massignop; populate p4(massignop._M_other); functions.push_back(function_type(massignop)); -#endif +#endif // Last. typename base_type::clear clear; functions.push_back(function_type(clear)); Index: libstdc++-v3/testsuite/util/hash_fn/string_ranged_hash_fn.hpp =================================================================== --- libstdc++-v3/testsuite/util/hash_fn/string_ranged_hash_fn.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/hash_fn/string_ranged_hash_fn.hpp (working copy) @@ -96,4 +96,4 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/io/prog_bar.hpp =================================================================== --- libstdc++-v3/testsuite/util/io/prog_bar.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/io/prog_bar.hpp (working copy) @@ -65,7 +65,7 @@ namespace __gnu_pbds private: prog_bar(const prog_bar& ); - prog_bar& + prog_bar& operator=(const prog_bar& ); private: Index: libstdc++-v3/testsuite/util/io/xml_test_formatter.hpp =================================================================== --- libstdc++-v3/testsuite/util/io/xml_test_formatter.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/io/xml_test_formatter.hpp (working copy) @@ -64,7 +64,7 @@ namespace __gnu_pbds { std::cout << detail::make_xml_name_start_tag("cntnr"); std::cout << detail::make_xml_attrib_val("name", name); - std::cout << detail::make_xml_name_start_tag_end_delimiter(); + std::cout << detail::make_xml_name_start_tag_end_delimiter(); std::cout << make_xml_tag("desc", desc); } Index: libstdc++-v3/testsuite/util/native_type/native_hash_map.hpp =================================================================== --- libstdc++-v3/testsuite/util/native_type/native_hash_map.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/native_type/native_hash_map.hpp (working copy) @@ -77,7 +77,7 @@ namespace __gnu_pbds static std::string name() { - return std::string("n_hash_map_") + return std::string("n_hash_map_") + (Cache_Hash ? std::string("cah") : std::string("ncah")); } @@ -89,7 +89,7 @@ namespace __gnu_pbds "value", (Cache_Hash ? std::string("true") : std::string("false"))); - return make_xml_tag("type", "value", "std_tr1_unordered_map", + return make_xml_tag("type", "value", "std_tr1_unordered_map", cache_hash_desc); } }; @@ -99,5 +99,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/native_type/native_hash_multimap.hpp =================================================================== --- libstdc++-v3/testsuite/util/native_type/native_hash_multimap.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/native_type/native_hash_multimap.hpp (working copy) @@ -143,4 +143,4 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/native_type/native_hash_set.hpp =================================================================== --- libstdc++-v3/testsuite/util/native_type/native_hash_set.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/native_type/native_hash_set.hpp (working copy) @@ -102,7 +102,7 @@ namespace __gnu_pbds static std::string name() { - return std::string("n_hash_set_") + return std::string("n_hash_set_") + (Cache_Hash ? std::string("cah") : std::string("ncah")); } @@ -113,7 +113,7 @@ namespace __gnu_pbds make_xml_tag("cache_hash_code", "value", Cache_Hash ? std::string("true") : std::string("false")); - return make_xml_tag("type", "value", "std_tr1_unordered_set", + return make_xml_tag("type", "value", "std_tr1_unordered_set", cache_hash_desc); } }; Index: libstdc++-v3/testsuite/util/native_type/native_hash_tag.hpp =================================================================== --- libstdc++-v3/testsuite/util/native_type/native_hash_tag.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/native_type/native_hash_tag.hpp (working copy) @@ -45,4 +45,4 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/native_type/native_multimap.hpp =================================================================== --- libstdc++-v3/testsuite/util/native_type/native_multimap.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/native_type/native_multimap.hpp (working copy) @@ -124,7 +124,7 @@ namespace __gnu_pbds } return base_type::end(); } - + static std::string name() { return std::string("n_mmap"); } Index: libstdc++-v3/testsuite/util/native_type/native_priority_queue.hpp =================================================================== --- libstdc++-v3/testsuite/util/native_type/native_priority_queue.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/native_type/native_priority_queue.hpp (working copy) @@ -221,4 +221,4 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/native_type/native_tree_tag.hpp =================================================================== --- libstdc++-v3/testsuite/util/native_type/native_tree_tag.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/native_type/native_tree_tag.hpp (working copy) @@ -46,4 +46,4 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/assoc/mem_usage/erase_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/assoc/mem_usage/erase_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/assoc/mem_usage/erase_test.hpp (working copy) @@ -88,7 +88,7 @@ namespace __gnu_pbds typedef __gnu_test::tracker_allocator_counter counter_type; __gnu_test::tracker_allocator alloc; - const size_t init_mem = counter_type::get_allocation_count() + const size_t init_mem = counter_type::get_allocation_count() - counter_type::get_deallocation_count(); Cntnr cntnr(ins_it_b, ins_it_e); @@ -95,7 +95,7 @@ namespace __gnu_pbds while (cntnr.size() > 1) cntnr.erase(*cntnr.begin()); - const size_t final_mem = counter_type::get_allocation_count() + const size_t final_mem = counter_type::get_allocation_count() - counter_type::get_deallocation_count(); assert(final_mem > init_mem); const size_t delta_mem = final_mem - init_mem; Index: libstdc++-v3/testsuite/util/performance/assoc/mem_usage/multimap_insert_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/assoc/mem_usage/multimap_insert_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/assoc/mem_usage/multimap_insert_test.hpp (working copy) @@ -108,12 +108,12 @@ namespace __gnu_pbds { typedef __gnu_test::tracker_allocator_counter counter_type; __gnu_test::tracker_allocator alloc; - const size_t init_mem = counter_type::get_allocation_count() + const size_t init_mem = counter_type::get_allocation_count() - counter_type::get_deallocation_count(); Cntnr cntnr; for (It ins_it = ins_it_b; ins_it != ins_it_e; ++ins_it) cntnr.insert((typename Cntnr::const_reference)(*ins_it)); - const size_t final_mem = counter_type::get_allocation_count() + const size_t final_mem = counter_type::get_allocation_count() - counter_type::get_deallocation_count(); assert(final_mem > init_mem); return (final_mem - init_mem); @@ -127,12 +127,12 @@ namespace __gnu_pbds { typedef __gnu_test::tracker_allocator_counter counter_type; __gnu_test::tracker_allocator alloc; - const size_t init_mem = counter_type::get_allocation_count() + const size_t init_mem = counter_type::get_allocation_count() - counter_type::get_deallocation_count(); Cntnr cntnr; for (It ins_it = ins_it_b; ins_it != ins_it_e; ++ins_it) cntnr[ins_it->first].insert(ins_it->second); - const size_t final_mem = counter_type::get_allocation_count() + const size_t final_mem = counter_type::get_allocation_count() - counter_type::get_deallocation_count(); assert(final_mem > init_mem); return (final_mem - init_mem); @@ -140,5 +140,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/assoc/timing/find_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/assoc/timing/find_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/assoc/timing/find_test.hpp (working copy) @@ -52,7 +52,7 @@ namespace __gnu_pbds class find_find_functor { public: - find_find_functor(Cntnr& contnr, It fnd_it_b, It fnd_it_e) + find_find_functor(Cntnr& contnr, It fnd_it_b, It fnd_it_e) : m_contnr(contnr), m_fnd_it_b(fnd_it_b), m_fnd_it_e(fnd_it_e) { } @@ -77,7 +77,7 @@ namespace __gnu_pbds class find_find_functor { public: - find_find_functor(Cntnr& contnr, It fnd_it_b, It fnd_it_e) + find_find_functor(Cntnr& contnr, It fnd_it_b, It fnd_it_e) : m_contnr(contnr), m_fnd_it_b(fnd_it_b), m_fnd_it_e(fnd_it_e) { } @@ -104,7 +104,7 @@ namespace __gnu_pbds class find_test : private __gnu_pbds::test::detail::timing_test_base { public: - find_test(It ins_b, It fnd_it_b, size_t ins_vn, size_t ins_vs, + find_test(It ins_b, It fnd_it_b, size_t ins_vn, size_t ins_vs, size_t ins_vm, size_t fnd_vn, size_t fnd_vs, size_t fnd_vm): m_ins_b(ins_b), m_fnd_it_b(fnd_it_b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm), m_fnd_vn(fnd_vn), m_fnd_vs(fnd_vs), m_fnd_vm(fnd_vm) @@ -162,5 +162,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/assoc/timing/insert_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/assoc/timing/insert_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/assoc/timing/insert_test.hpp (working copy) @@ -53,7 +53,7 @@ namespace __gnu_pbds class insert_insert_functor { public: - insert_insert_functor(It ins_it_b, It ins_it_e) + insert_insert_functor(It ins_it_b, It ins_it_e) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e) { } Index: libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_find_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_find_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_find_test.hpp (working copy) @@ -100,7 +100,7 @@ namespace __gnu_pbds { Cntnr cntnr; for (It fnd_it = m_fnd_it_b; fnd_it != m_fnd_it_e; ++fnd_it) - if (m_r_container.find(const_reference(*fnd_it)) + if (m_r_container.find(const_reference(*fnd_it)) == m_r_container.end()) ++not_found_count; } @@ -118,7 +118,7 @@ namespace __gnu_pbds template - class multimap_find_test + class multimap_find_test : private __gnu_pbds::test::detail::timing_test_base { public: @@ -187,5 +187,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_insert_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_insert_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_insert_test.hpp (working copy) @@ -52,7 +52,7 @@ namespace __gnu_pbds class multimap_insert_functor { public: - multimap_insert_functor(It ins_it_b, It ins_it_e) + multimap_insert_functor(It ins_it_b, It ins_it_e) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e) { } @@ -76,7 +76,7 @@ namespace __gnu_pbds class multimap_insert_functor { public: - multimap_insert_functor(It ins_it_b, It ins_it_e) + multimap_insert_functor(It ins_it_b, It ins_it_e) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e) { } @@ -98,11 +98,11 @@ namespace __gnu_pbds } // namespace detail template - class multimap_insert_test + class multimap_insert_test : private __gnu_pbds::test::detail::timing_test_base { public: - multimap_insert_test(It b, size_t ins_vn, size_t ins_vs, size_t ins_vm) + multimap_insert_test(It b, size_t ins_vn, size_t ins_vs, size_t ins_vm) : m_ins_b(b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm) { } Index: libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_find_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_find_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_find_test.hpp (working copy) @@ -51,7 +51,7 @@ namespace __gnu_pbds class subscript_find_functor { public: - subscript_find_functor(Cntnr& container, It fnd_it_b, It fnd_it_e) + subscript_find_functor(Cntnr& container, It fnd_it_b, It fnd_it_e) : m_r_container(container), m_fnd_it_b(fnd_it_b), m_fnd_it_e(fnd_it_e) { } @@ -79,7 +79,7 @@ namespace __gnu_pbds class subscript_find_test : private __gnu_pbds::test::detail::timing_test_base { public: - subscript_find_test(It ins_b, It b, size_t ins_vn, size_t ins_vs, + subscript_find_test(It ins_b, It b, size_t ins_vn, size_t ins_vs, size_t ins_vm, size_t vn, size_t vs, size_t vm) : m_ins_b(ins_b), m_fnd_b(b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm), m_fnd_vn(vn), m_fnd_vs(vs), m_fnd_vm(vm) @@ -140,5 +140,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_insert_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_insert_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_insert_test.hpp (working copy) @@ -52,7 +52,7 @@ namespace __gnu_pbds class subscript_insert_functor { public: - subscript_insert_functor(It ins_it_b, It ins_it_e) + subscript_insert_functor(It ins_it_b, It ins_it_e) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e) { } @@ -78,9 +78,9 @@ namespace __gnu_pbds class subscript_insert_test : private __gnu_pbds::test::detail::timing_test_base { public: - subscript_insert_test(It ins_b, It b, size_t ins_vn, size_t ins_vs, + subscript_insert_test(It ins_b, It b, size_t ins_vn, size_t ins_vs, size_t ins_vm, size_t vn, size_t vs, size_t vm) - : m_ins_b(ins_b), m_fnd_b(b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), + : m_ins_b(ins_b), m_fnd_b(b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm), m_fnd_vn(vn), m_fnd_vs(vs), m_fnd_vm(vm) { } @@ -130,5 +130,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/assoc/timing/tree_order_statistics_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/assoc/timing/tree_order_statistics_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/assoc/timing/tree_order_statistics_test.hpp (working copy) @@ -115,7 +115,7 @@ namespace __gnu_pbds } // namespace detail template - class tree_order_statistics_test + class tree_order_statistics_test : private __gnu_pbds::test::detail::timing_test_base { public: @@ -151,7 +151,7 @@ namespace __gnu_pbds operator()(Cntnr) { typedef xml_result_set_performance_formatter formatter_type; - formatter_type res_set_fmt(string_form::name(), + formatter_type res_set_fmt(string_form::name(), string_form::desc()); for (size_t v = m_vn; v < m_vm; v += m_vs) @@ -172,5 +172,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/assoc/timing/tree_split_join_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/assoc/timing/tree_split_join_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/assoc/timing/tree_split_join_test.hpp (working copy) @@ -154,5 +154,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/priority_queue/mem_usage/pop_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/priority_queue/mem_usage/pop_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/priority_queue/mem_usage/pop_test.hpp (working copy) @@ -88,7 +88,7 @@ namespace __gnu_pbds typedef __gnu_test::tracker_allocator_counter counter_type; __gnu_test::tracker_allocator alloc; - const size_t init_mem = counter_type::get_allocation_count() + const size_t init_mem = counter_type::get_allocation_count() - counter_type::get_deallocation_count(); Cntnr cntnr; for (It ins_it = ins_it_b; ins_it != ins_it_e; ++ins_it) @@ -97,7 +97,7 @@ namespace __gnu_pbds while (cntnr.size() > 1) cntnr.pop(); - const size_t final_mem = counter_type::get_allocation_count() + const size_t final_mem = counter_type::get_allocation_count() - counter_type::get_deallocation_count(); assert(final_mem > init_mem); const size_t delta_mem = final_mem - init_mem; @@ -107,5 +107,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/priority_queue/timing/join_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/priority_queue/timing/join_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/priority_queue/timing/join_test.hpp (working copy) @@ -122,9 +122,9 @@ namespace __gnu_pbds typedef double_push_join_functor psh_jn_fnct; typedef xml_result_set_performance_formatter formatter_type; - formatter_type res(string_form::name(), + formatter_type res(string_form::name(), string_form::desc()); - + for (size_t n = 0; m_ins_vn + n* m_ins_vs < m_ins_vm; ++n) { const size_t v = m_ins_vn + n * m_ins_vs; @@ -163,5 +163,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/priority_queue/timing/modify_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/priority_queue/timing/modify_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/priority_queue/timing/modify_test.hpp (working copy) @@ -54,7 +54,7 @@ namespace __gnu_pbds class push_functor { public: - push_functor(It ins_it_b, It ins_it_e) + push_functor(It ins_it_b, It ins_it_e) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e) { } @@ -87,7 +87,7 @@ namespace __gnu_pbds typedef typename Cntnr::value_type value_type; public: - push_modify_functor(It ins_it_b, It ins_it_e, value_type mod_val) + push_modify_functor(It ins_it_b, It ins_it_e, value_type mod_val) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e), m_mod_val(mod_val) { } @@ -119,7 +119,7 @@ namespace __gnu_pbds class push_functor { public: - push_functor(It ins_it_b, It ins_it_e) + push_functor(It ins_it_b, It ins_it_e) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e) { } @@ -144,7 +144,7 @@ namespace __gnu_pbds class push_functor { public: - push_functor(It ins_it_b, It ins_it_e) + push_functor(It ins_it_b, It ins_it_e) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e) { } @@ -176,7 +176,7 @@ namespace __gnu_pbds typedef typename Cntnr::value_type value_type; public: - push_modify_functor(It ins_it_b, It ins_it_e, value_type mod_val) + push_modify_functor(It ins_it_b, It ins_it_e, value_type mod_val) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e), m_mod_val(mod_val) { } @@ -217,7 +217,7 @@ namespace __gnu_pbds typedef typename Cntnr::const_reference const_reference; public: - push_modify_functor(It ins_it_b, It ins_it_e, value_type mod_val) + push_modify_functor(It ins_it_b, It ins_it_e, value_type mod_val) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e), m_mod_val(mod_val) { } @@ -263,7 +263,7 @@ namespace __gnu_pbds modify(Cntnr, It ins_it_b, It ins_it_e) { typedef typename Cntnr::const_reference const_reference; - Cntnr cntnr; + Cntnr cntnr; for (It ins_it = ins_it_b; ins_it != ins_it_e; ++ins_it) cntnr.modify(const_reference(*ins_it)); } Index: libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_pop_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_pop_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_pop_test.hpp (working copy) @@ -53,7 +53,7 @@ namespace __gnu_pbds class push_pop_push_pop_functor { public: - push_pop_push_pop_functor(It ins_it_b, It ins_it_e) + push_pop_push_pop_functor(It ins_it_b, It ins_it_e) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e) { } @@ -107,7 +107,7 @@ namespace __gnu_pbds const size_t m_ins_vm; }; - + template template void @@ -115,9 +115,9 @@ namespace __gnu_pbds operator()(Cntnr) { typedef xml_result_set_performance_formatter formatter_type; - formatter_type res_set_fmt(string_form::name(), + formatter_type res_set_fmt(string_form::name(), string_form::desc()); - + for (size_t i = 0; m_ins_vn + i * m_ins_vs < m_ins_vm; ++i) { const size_t v = m_ins_vn + i * m_ins_vs; @@ -137,5 +137,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_test.hpp (working copy) @@ -53,7 +53,7 @@ namespace __gnu_pbds class push_push_functor { public: - push_push_functor(It ins_it_b, It ins_it_e) + push_push_functor(It ins_it_b, It ins_it_e) : m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e) { } @@ -140,5 +140,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/performance/time/timing_test_base.hpp =================================================================== --- libstdc++-v3/testsuite/util/performance/time/timing_test_base.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/performance/time/timing_test_base.hpp (working copy) @@ -113,5 +113,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/regression/basic_type.hpp =================================================================== --- libstdc++-v3/testsuite/util/regression/basic_type.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/regression/basic_type.hpp (working copy) @@ -91,4 +91,4 @@ namespace test } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/regression/common_type.hpp =================================================================== --- libstdc++-v3/testsuite/util/regression/common_type.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/regression/common_type.hpp (working copy) @@ -111,10 +111,10 @@ namespace test typedef tl_t min_tl_t; }; - + // Sequence types. typedef pq_common_types, alloc_type> pq_types; - + typedef pq_types::regression_tl pq_tl_t; typedef pq_tl_t min_pq_tl_t; @@ -126,14 +126,14 @@ namespace test public: typedef typename base_type::value_type value_type; - typedef typename base_type::pointer pointer; - typedef typename base_type::const_pointer const_pointer; - typedef typename base_type::reference reference; - typedef typename base_type::const_reference const_reference; - typedef typename base_type::iterator iterator; - typedef typename base_type::const_iterator const_iterator; - typedef typename base_type::reverse_iterator reverse_iterator; - typedef typename base_type::const_reverse_iterator const_reverse_iterator; + typedef typename base_type::pointer pointer; + typedef typename base_type::const_pointer const_pointer; + typedef typename base_type::reference reference; + typedef typename base_type::const_reference const_reference; + typedef typename base_type::iterator iterator; + typedef typename base_type::const_iterator const_iterator; + typedef typename base_type::reverse_iterator reverse_iterator; + typedef typename base_type::const_reverse_iterator const_reverse_iterator; typedef typename base_type::size_type size_type; typedef typename base_type::difference_type difference_type; typedef typename base_type::allocator_type allocator_type; @@ -141,7 +141,7 @@ namespace test typedef __gnu_pbds::sequence_tag container_category; typedef std::less<_Tp> cmp_fn; - const cmp_fn& + const cmp_fn& get_cmp_fn() const { return _M_cmp; } @@ -159,7 +159,7 @@ namespace test cmp_fn _M_cmp; }; - + typedef vector_adaptor vector_type; typedef __gnu_cxx::typelist::create1::type vector_tl_t; @@ -186,4 +186,4 @@ namespace test } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.h =================================================================== --- libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.h (revision 235613) +++ libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.h (working copy) @@ -60,7 +60,7 @@ namespace detail { public: - container_rand_regression_test(unsigned long, size_t, size_t, double, + container_rand_regression_test(unsigned long, size_t, size_t, double, double, double, double, double, bool); virtual @@ -301,43 +301,43 @@ namespace detail cmp_(const Cntnr&, const native_type&); void - order_preserving_cmp_imp(const Cntnr&, const native_type&, + order_preserving_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::false_type); void - order_preserving_cmp_imp(const Cntnr&, const native_type&, + order_preserving_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::true_type); void - back_order_preserving_cmp_imp(const Cntnr&, const native_type&, + back_order_preserving_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::false_type); void - back_order_preserving_cmp_imp(const Cntnr&, const native_type&, + back_order_preserving_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::true_type); void - reverse_iteration_cmp_imp(const Cntnr&, const native_type&, + reverse_iteration_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::false_type); void - reverse_iteration_cmp_imp(const Cntnr&, const native_type&, + reverse_iteration_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::true_type); void - order_statistics_cmp_imp(const Cntnr&, const native_type&, + order_statistics_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::false_type); void - order_statistics_cmp_imp(const Cntnr&, const native_type&, + order_statistics_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::true_type); void - prefix_search_cmp_imp(const Cntnr&, const native_type&, + prefix_search_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::false_type); void - prefix_search_cmp_imp(const Cntnr&, const native_type&, + prefix_search_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::true_type); template @@ -349,19 +349,19 @@ namespace detail back_it_cmp_imp(Const_It, Const_It, Const_Native_It, Const_Native_It); void - lower_bound_cmp_imp(const Cntnr&, const native_type&, + lower_bound_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::false_type); void - lower_bound_cmp_imp(const Cntnr&, const native_type&, + lower_bound_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::true_type); void - upper_bound_cmp_imp(const Cntnr&, const native_type&, + upper_bound_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::false_type); void - upper_bound_cmp_imp(const Cntnr&, const native_type&, + upper_bound_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::true_type); void @@ -372,7 +372,7 @@ namespace detail struct destructor_printer { - destructor_printer(const std::string& r_msg) + destructor_printer(const std::string& r_msg) : m_msg(r_msg), m_print(true) { } void @@ -384,7 +384,7 @@ namespace detail if (!m_print) return; - std::cerr << std::endl << "Uncaught exception: " << std::endl + std::cerr << std::endl << "Uncaught exception: " << std::endl << m_msg << std::endl; } @@ -411,7 +411,7 @@ namespace detail #ifdef PB_DS_REGRESSION_TRACE #define PB_DS_TRACE(X) std::cerr << X << std::endl -#else +#else #define PB_DS_TRACE(X) #endif Index: libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.tcc =================================================================== --- libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.tcc (revision 235613) +++ libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.tcc (working copy) @@ -40,9 +40,9 @@ // Constructors/Destructors. PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: -container_rand_regression_test(unsigned long seed, size_t n, size_t m, - double tp, double ip, double ep, double cp, - double mp, bool disp) +container_rand_regression_test(unsigned long seed, size_t n, size_t m, + double tp, double ip, double ep, double cp, + double mp, bool disp) : m_seed((seed == 0) ? twister_rand_gen::get_time_determined_seed() : seed), m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_ep(ep), m_cp(cp), m_mp(mp), m_disp(disp), m_p_c(0) @@ -383,7 +383,7 @@ it_constructor_imp(__gnu_pbds::pat_trie_tag) m_native_c.clear(); break; case 1: - p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), + p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_access_traits()); break; default: @@ -406,7 +406,7 @@ it_constructor_imp(__gnu_pbds::pat_trie_tag) PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: -cmp(const Cntnr& r_c, const native_type& r_native_c, +cmp(const Cntnr& r_c, const native_type& r_native_c, const std::string& r_call_fn) { m_alloc.set_probability(1); @@ -441,7 +441,7 @@ basic_cmp_(const Cntnr& r_c, const native_type& r_ if (static_cast(std::distance(r_c.begin(), r_c.end())) != r_c.size()) PB_DS_THROW_IF_FAILED(false, static_cast(std::distance(r_c.begin(), r_c.end())) << " " << static_cast(r_c.size()), &r_c, &r_native_c); - + typename native_type::const_iterator it = r_native_c.begin(); while (it != r_native_c.end()) { @@ -471,8 +471,8 @@ cmp_(const Cntnr& r_c, const native_type& r_native enum { order_preserving = container_traits::order_preserving, - back_order_preserving = container_traits::order_preserving - && + back_order_preserving = container_traits::order_preserving + && !__gnu_pbds::detail::is_same< typename std::iterator_traits< typename cntnr::const_iterator>::iterator_category, @@ -550,7 +550,7 @@ order_preserving_cmp_imp(const Cntnr& r_c, const n PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: -back_order_preserving_cmp_imp(const Cntnr&, const native_type&, +back_order_preserving_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::false_type) { } @@ -557,7 +557,7 @@ PB_DS_CLASS_C_DEC:: PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: -back_order_preserving_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, +back_order_preserving_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type) { PB_DS_SET_DESTRUCT_PRINT @@ -572,7 +572,7 @@ PB_DS_CLASS_C_DEC:: PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: -reverse_iteration_cmp_imp(const Cntnr&, const native_type&, +reverse_iteration_cmp_imp(const Cntnr&, const native_type&, __gnu_pbds::detail::false_type) { } @@ -688,7 +688,7 @@ prefix_search_cmp_imp(const Cntnr& r_c, const nati typename native_type::const_iterator native_start_it = r_native_c.begin(); - while (native_start_it != r_native_c.end() && + while (native_start_it != r_native_c.end() && !test_traits::prefix_match(k, test_traits::extract_native_key(*native_start_it))) ++native_start_it; @@ -701,7 +701,7 @@ prefix_search_cmp_imp(const Cntnr& r_c, const nati if (native_end_it != r_native_c.end()) ++native_end_it; } - while (native_end_it != r_native_c.end() && + while (native_end_it != r_native_c.end() && test_traits::prefix_match(k, test_traits::extract_native_key(*native_end_it))); @@ -719,7 +719,7 @@ PB_DS_CLASS_T_DEC template void PB_DS_CLASS_C_DEC:: -it_cmp_imp(Const_It b, Const_It e, Const_Native_It native_b, +it_cmp_imp(Const_It b, Const_It e, Const_Native_It native_b, Const_Native_It native_e) { PB_DS_SET_DESTRUCT_PRINT @@ -733,7 +733,7 @@ PB_DS_CLASS_C_DEC:: << static_cast(native_dist), m_p_c, &m_native_c); } - + while (b != e) { PB_DS_THROW_IF_FAILED(native_b != native_e, "", m_p_c, &m_native_c); @@ -756,7 +756,7 @@ PB_DS_CLASS_T_DEC template void PB_DS_CLASS_C_DEC:: -back_it_cmp_imp(Const_It b, Const_It e, Const_Native_It native_b, +back_it_cmp_imp(Const_It b, Const_It e, Const_Native_It native_b, Const_Native_It native_e) { PB_DS_SET_DESTRUCT_PRINT @@ -880,7 +880,7 @@ operator()() // Track allocation from this point only. const size_t memory_label = 775; m_alloc.seed(m_seed); - m_alloc.set_label(memory_label); + m_alloc.set_label(memory_label); prog_bar pb(m_n, std::cout, m_disp); m_i = 0; @@ -993,7 +993,7 @@ operator()() } catch (...) { - std::cerr << "Failed at index " << static_cast(m_i) + std::cerr << "Failed at index " << static_cast(m_i) << std::endl; delete m_p_c; throw; @@ -1002,7 +1002,7 @@ operator()() // Clean up, then check for allocation by special label, set above. delete m_p_c; - try + try { m_alloc.check(memory_label); } catch (...) { @@ -1076,7 +1076,7 @@ insert() typename cntnr::point_const_iterator found_it = m_p_c->find(r_k); const bool existed = (found_it != m_p_c->end()); const std::pair ins_ret = m_p_c->insert(v); - + if (ins_ret.second) { PB_DS_THROW_IF_FAILED(!existed, "", m_p_c, &m_native_c); @@ -1096,7 +1096,7 @@ insert() { PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c); } - + PB_DS_COND_COMPARE(*m_p_c, m_native_c); PB_DS_CANCEL_DESTRUCT_PRINT return done; @@ -1143,7 +1143,7 @@ subscript_imp(__gnu_pbds::detail::false_type) { done = false; } - + PB_DS_COND_COMPARE(*m_p_c, m_native_c); PB_DS_CANCEL_DESTRUCT_PRINT return done; @@ -1168,7 +1168,7 @@ subscript_imp(__gnu_pbds::detail::true_type) { done = false; } - + PB_DS_COND_COMPARE(*m_p_c, m_native_c); PB_DS_CANCEL_DESTRUCT_PRINT return done; @@ -1207,10 +1207,10 @@ erase() const bool ersd = m_p_c->erase(k); const bool native_ersd = m_native_c.erase(test_traits::native_key(k)) != 0; - PB_DS_THROW_IF_FAILED(ersd == native_ersd, ersd << " " << native_ersd, + PB_DS_THROW_IF_FAILED(ersd == native_ersd, ersd << " " << native_ersd, m_p_c, &m_native_c); - PB_DS_THROW_IF_FAILED(m_p_c->find(k) == m_p_c->end(), "", + PB_DS_THROW_IF_FAILED(m_p_c->find(k) == m_p_c->end(), "", m_p_c, &m_native_c); } catch(__gnu_cxx::forced_error&) @@ -1239,15 +1239,15 @@ erase_if() typedef typename std::iterator_traits::reference it_const_reference; - + typedef typename test_traits::template erase_if_fn erase_if_fn_t; - + m_alloc.set_probability(m_tp); - - const size_t ersd = m_p_c->erase_if(erase_if_fn_t()); - const size_t native_ersd = test_traits::erase_if(m_native_c); + + const size_t ersd = m_p_c->erase_if(erase_if_fn_t()); + const size_t native_ersd = test_traits::erase_if(m_native_c); PB_DS_THROW_IF_FAILED(ersd == native_ersd, ersd << " " << native_ersd, m_p_c, &m_native_c); } @@ -1254,11 +1254,11 @@ erase_if() catch(__gnu_cxx::forced_error&) { done = false; - PB_DS_THROW_IF_FAILED(container_traits::erase_can_throw, - container_traits::erase_can_throw, + PB_DS_THROW_IF_FAILED(container_traits::erase_can_throw, + container_traits::erase_can_throw, m_p_c, &m_native_c); } - + PB_DS_COND_COMPARE(*m_p_c, m_native_c); PB_DS_CANCEL_DESTRUCT_PRINT return done; @@ -1306,22 +1306,22 @@ erase_it_imp(__gnu_pbds::detail::true_type) const bool found = found_it != m_p_c->end(); const bool native_found = native_it != m_native_c.end(); - + PB_DS_THROW_IF_FAILED( found == native_found, found << " " << native_found, m_p_c, &m_native_c); - + typename cntnr::const_iterator next_it = found_it; if (next_it != m_p_c->end()) ++next_it; - + typename cntnr::iterator next_ers_it = m_p_c->erase(found_it); - + if (native_it != m_native_c.end()) m_native_c.erase(native_it); - + bool range_guarantee = __gnu_pbds::detail::is_same< typename container_traits::invalidation_guarantee, __gnu_pbds::range_invalidation_guarantee>::value ; @@ -1347,7 +1347,7 @@ erase_rev_it() { enum { - erase_iterators = container_traits::order_preserving + erase_iterators = container_traits::order_preserving && container_traits::reverse_iteration }; @@ -1373,20 +1373,20 @@ erase_rev_it_imp(__gnu_pbds::detail::true_type) try { - m_alloc.set_probability(0); - const key_type k = test_traits::generate_key(m_g, m_m); + m_alloc.set_probability(0); + const key_type k = test_traits::generate_key(m_g, m_m); m_alloc.set_probability(m_tp); - + typename cntnr::iterator found_it = m_p_c->find(k); typename native_type::iterator native_it = m_native_c.find(test_traits::native_key(k)); - + typename cntnr::const_reverse_iterator next_it = found_it; if (next_it != m_p_c->end()) ++next_it; - + typename cntnr::reverse_iterator next_ers_it = m_p_c->erase((typename cntnr::reverse_iterator)found_it); - + PB_DS_THROW_IF_FAILED(next_ers_it == next_it, "", m_p_c, &m_native_c); if (native_it != m_native_c.end()) @@ -1394,9 +1394,9 @@ erase_rev_it_imp(__gnu_pbds::detail::true_type) } catch(__gnu_cxx::forced_error&) { - done = false; - PB_DS_THROW_IF_FAILED(container_traits::erase_can_throw, - container_traits::erase_can_throw, + done = false; + PB_DS_THROW_IF_FAILED(container_traits::erase_can_throw, + container_traits::erase_can_throw, m_p_c, &m_native_c); } @@ -1735,13 +1735,13 @@ split_join_imp(__gnu_pbds::detail::true_type) native_type native_lhs(m_native_c); native_type native_rhs; const key_type k = test_traits::generate_key(m_g, m_m); - + m_alloc.set_probability(m_tp); lhs.split(k, rhs); - + typename native_type::const_iterator it = native_lhs.upper_bound(test_traits::native_key(k)); - + while (!native_lhs.empty()&& it != native_lhs.end()) { native_rhs.insert(*it); @@ -1750,15 +1750,15 @@ split_join_imp(__gnu_pbds::detail::true_type) native_lhs.erase(test_traits::extract_native_key(*it)); it = next_it; } - + PB_DS_COND_COMPARE(lhs, native_lhs); PB_DS_COND_COMPARE(rhs, native_rhs); - + m_alloc.set_probability(m_tp); - + if (m_g.get_prob() < 0.5) lhs.swap(rhs); - + lhs.join(rhs); PB_DS_THROW_IF_FAILED(rhs.size() == 0, rhs.size(), m_p_c, &m_native_c); PB_DS_THROW_IF_FAILED(rhs.empty(), rhs.size(), m_p_c, &m_native_c); @@ -1767,11 +1767,11 @@ split_join_imp(__gnu_pbds::detail::true_type) catch(__gnu_cxx::forced_error&) { done = false; - PB_DS_THROW_IF_FAILED(container_traits::split_join_can_throw, - container_traits::split_join_can_throw, + PB_DS_THROW_IF_FAILED(container_traits::split_join_can_throw, + container_traits::split_join_can_throw, m_p_c, &m_native_c); } - + PB_DS_COND_COMPARE(*m_p_c, m_native_c); PB_DS_CANCEL_DESTRUCT_PRINT return done; Index: libstdc++-v3/testsuite/util/regression/rand/assoc/rand_regression_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/regression/rand/assoc/rand_regression_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/regression/rand/assoc/rand_regression_test.hpp (working copy) @@ -58,11 +58,11 @@ namespace detail struct rand_reg_test { public: - rand_reg_test(size_t seed, size_t n, size_t m, double tp, double ip, - double ep, double cp, double mp, bool d) - : m_sd(seed), m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_ep(ep), m_cp(cp), + rand_reg_test(size_t seed, size_t n, size_t m, double tp, double ip, + double ep, double cp, double mp, bool d) + : m_sd(seed), m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_ep(ep), m_cp(cp), m_mp(mp), m_disp(d) - { + { if (m_disp) xml_test_rand_regression_formatter(seed, n, m, tp, ip, ep, cp, mp); } @@ -72,7 +72,7 @@ namespace detail operator()(Cntnr) { unsigned long ul = static_cast(m_sd); - container_rand_regression_test t(ul, m_n, m_n, m_tp, m_ip, + container_rand_regression_test t(ul, m_n, m_n, m_tp, m_ip, m_ep, m_cp, m_mp, m_disp); t(); } @@ -93,7 +93,7 @@ namespace detail usage(const std::string& r_name); void - verify_params(size_t&, size_t&, size_t&, + verify_params(size_t&, size_t&, size_t&, double&, double&, double&, double&, double&, bool&); } // namespace detail @@ -107,7 +107,7 @@ namespace detail size_t sd = twister_rand_gen::get_time_determined_seed(); double tp = 0.2; double ip = 0.6; - double ep = 0.2; + double ep = 0.2; double cp = 0.001; double mp = 0.25; bool disp = true; // show progress @@ -146,8 +146,8 @@ namespace detail usage(const std::string& name) { using namespace std; - cerr << "usage: " << name - << " ['t' | 'f']" + cerr << "usage: " << name + << " ['t' | 'f']" << endl << endl; cerr << "This test performs basic regression tests on various associative containers." @@ -175,8 +175,8 @@ namespace detail } inline void - verify_params(size_t& r_seed, size_t& r_n, - size_t& r_m, double& r_tp, double& r_ip, double& r_ep, + verify_params(size_t& r_seed, size_t& r_n, + size_t& r_m, double& r_tp, double& r_ip, double& r_ep, double& r_cp, double& r_mp, bool& r_d) { verify_prob(r_tp); Index: libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.h =================================================================== --- libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.h (revision 235613) +++ libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.h (working copy) @@ -145,20 +145,20 @@ namespace detail split_join(); void - cmp(const Cntnr& r_container, const native_type& r_native_c, + cmp(const Cntnr& r_container, const native_type& r_native_c, const std::string& r_call_fn); void - print_container(const native_type& r_cnt, + print_container(const native_type& r_cnt, std::ostream& r_os = std::cerr) const; void - print_container(const cntnr& r_cnt, + print_container(const cntnr& r_cnt, std::ostream& r_os = std::cerr) const; struct destructor_printer { - destructor_printer(const std::string& r_msg) + destructor_printer(const std::string& r_msg) : m_msg(r_msg), m_print(true) { } void @@ -169,7 +169,7 @@ namespace detail { if (m_print) { - std::cerr << std::endl << "Uncaught exception: " << std::endl + std::cerr << std::endl << "Uncaught exception: " << std::endl << m_msg << std::endl; } } @@ -195,14 +195,14 @@ namespace detail size_t m_i; public: - container_rand_regression_test(unsigned long seed, size_t n, size_t m, - double tp, double ip, double dp, - double ep, double cp, double mp, + container_rand_regression_test(unsigned long seed, size_t n, size_t m, + double tp, double ip, double dp, + double ep, double cp, double mp, bool disp); virtual ~container_rand_regression_test(); - + void operator()(); }; @@ -210,7 +210,7 @@ namespace detail #ifdef PB_DS_REGRESSION_TRACE # define PB_DS_TRACE(X) std::cerr << X << std::endl -#else +#else # define PB_DS_TRACE(X) #endif Index: libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.tcc =================================================================== --- libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.tcc (revision 235613) +++ libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.tcc (working copy) @@ -40,9 +40,9 @@ // Constructor, copy constructor, assignment and destructor. PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: -container_rand_regression_test(unsigned long seed, size_t n, size_t m, - double tp, double ip, double dp, double ep, - double cp, double mp, bool disp) +container_rand_regression_test(unsigned long seed, size_t n, size_t m, + double tp, double ip, double dp, double ep, + double cp, double mp, bool disp) : m_seed(seed == 0 ? twister_rand_gen::get_time_determined_seed(): seed), m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_dp(dp), m_ep(ep), m_cp(cp), m_mp(mp), m_disp(disp), m_p_c(0) @@ -202,20 +202,20 @@ cmp(const Cntnr& c, const native_type& native, con try { m_alloc.set_probability(1); - + const size_t size = c.size(); const size_t native_size = native.size(); _GLIBCXX_THROW_IF(size != native_size, size << " " << native_size, &c, &native); - + const bool empty = c.empty(); const bool native_empty = native.empty(); - _GLIBCXX_THROW_IF(empty != native_empty, empty << " " << native_empty, + _GLIBCXX_THROW_IF(empty != native_empty, empty << " " << native_empty, &c, &native); - + const size_t it_size = std::distance(c.begin(), c.end()); _GLIBCXX_THROW_IF(it_size != size, it_size << " " << size, &c, &native); - + if (!c.empty()) { const std::string native_top = native.top(); @@ -222,7 +222,7 @@ cmp(const Cntnr& c, const native_type& native, con const std::string top = test_traits::native_value(c.top()); const bool top_smaller = std::less()(top, native_top); const bool top_larger = std::less()(native_top, top); - + if (top_smaller || top_larger) _GLIBCXX_THROW_IF(true, top << " " << native_top, &c, &native); } @@ -231,7 +231,7 @@ cmp(const Cntnr& c, const native_type& native, con { _GLIBCXX_THROW_IF(true, "call-fn: " + callfn, &c, &native); } - + notify.cancel(); } @@ -349,10 +349,10 @@ operator()() allocator_type::set_label(0); delete m_p_c; - try - { + try + { for (size_t n = starting_label; n <= m_n; ++n) - m_alloc.check(n); + m_alloc.check(n); } catch (std::logic_error& obj) { @@ -542,19 +542,19 @@ erase_if() typedef typename std::iterator_traits::reference it_const_reference; - + m_alloc.set_probability(1); - + typedef typename test_traits::template erase_if_fn erase_if_fn_t; - + const size_t ersd = m_p_c->erase_if(erase_if_fn_t()); - + typedef typename test_traits::template erase_if_fn native_erase_if_fn_t; - + const size_t native_ersd = m_native_c.erase_if(native_erase_if_fn_t()); _GLIBCXX_THROW_IF(ersd != native_ersd, ersd << " " << native_ersd, @@ -562,7 +562,7 @@ erase_if() } catch(__gnu_cxx::forced_error&) { - done = false; + done = false; _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c); } @@ -582,19 +582,19 @@ erase_it() bool done = true; try { - m_alloc.set_probability(1); - typename cntnr::iterator it = m_p_c->begin(); + m_alloc.set_probability(1); + typename cntnr::iterator it = m_p_c->begin(); std::advance(it, m_g.get_unsigned_long(0, m_p_c->size())); - + if (it != m_p_c->end()) { - m_native_c.erase(*it); + m_native_c.erase(*it); m_p_c->erase(it); } } catch(__gnu_cxx::forced_error&) { - done = false; + done = false; _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c); } @@ -694,34 +694,34 @@ split_join() Cntnr rhs; native_type native_lhs(m_native_c); m_alloc.set_probability(m_tp); - + typedef typename test_traits::template erase_if_fn split_fn_t; lhs.split(split_fn_t(), rhs); - + typedef typename test_traits::template erase_if_fn native_split_fn_t; - - native_type native_rhs; - native_lhs.split(native_split_fn_t(), native_rhs); + + native_type native_rhs; + native_lhs.split(native_split_fn_t(), native_rhs); PB_DS_COND_COMPARE(lhs, native_lhs); PB_DS_COND_COMPARE(rhs, native_rhs); - + m_alloc.set_probability(m_tp); - + if (m_g.get_prob() < 0.5) - lhs.swap(rhs); + lhs.swap(rhs); lhs.join(rhs); - + _GLIBCXX_THROW_IF(rhs.size() != 0, rhs.size(), m_p_c, &m_native_c); _GLIBCXX_THROW_IF(!rhs.empty(), rhs.size(), m_p_c, &m_native_c); } catch(__gnu_cxx::forced_error&) { - done = false; + done = false; const bool b = __gnu_pbds::container_traits::split_join_can_throw; _GLIBCXX_THROW_IF(!b, b, m_p_c, &m_native_c); } - + PB_DS_COND_COMPARE(*m_p_c, m_native_c); notify.cancel(); return done; Index: libstdc++-v3/testsuite/util/regression/rand/priority_queue/rand_regression_test.hpp =================================================================== --- libstdc++-v3/testsuite/util/regression/rand/priority_queue/rand_regression_test.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/regression/rand/priority_queue/rand_regression_test.hpp (working copy) @@ -56,11 +56,11 @@ namespace detail struct rand_reg_test { public: - rand_reg_test(size_t seed, size_t n, size_t m, double tp, double ip, - double dp, double ep, double cp, double mp, bool d) - : m_sd(seed), m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_dp(dp), m_ep(ep), + rand_reg_test(size_t seed, size_t n, size_t m, double tp, double ip, + double dp, double ep, double cp, double mp, bool d) + : m_sd(seed), m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_dp(dp), m_ep(ep), m_cp(cp), m_mp(mp), m_disp(d) - { + { if (m_disp) xml_test_rand_regression_formatter(seed, n, m, tp, ip, ep, cp, mp); } @@ -70,7 +70,7 @@ namespace detail operator()(Cntnr) { unsigned long ul = static_cast(m_sd); - container_rand_regression_test t(ul, m_n, m_n, m_tp, m_ip, m_dp, + container_rand_regression_test t(ul, m_n, m_n, m_tp, m_ip, m_dp, m_ep, m_cp, m_mp, m_disp); t(); } @@ -92,7 +92,7 @@ namespace detail usage(const std::string& r_name); void - verify_params(size_t&, size_t&, size_t&, + verify_params(size_t&, size_t&, size_t&, double&, double&, double&, double&, double&, double&, bool&); } // namespace detail @@ -107,7 +107,7 @@ namespace detail double tp = 0.2; double ip = 0.6; double dp = 0.1; - double ep = 0.2; + double ep = 0.2; double cp = 0.001; double mp = 1; bool disp = true; // show progress @@ -175,8 +175,8 @@ namespace detail } inline void - verify_params(size_t& r_seed, size_t& r_n, - size_t& r_m, double& r_tp, double& r_ip, double& r_dp, + verify_params(size_t& r_seed, size_t& r_n, + size_t& r_m, double& r_tp, double& r_ip, double& r_dp, double& r_ep, double& r_cp, double& r_mp, bool& r_d) { verify_prob(r_tp); Index: libstdc++-v3/testsuite/util/regression/rand/xml_formatter.hpp =================================================================== --- libstdc++-v3/testsuite/util/regression/rand/xml_formatter.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/regression/rand/xml_formatter.hpp (working copy) @@ -49,8 +49,8 @@ namespace __gnu_pbds struct xml_test_rand_regression_formatter : public xml_test_formatter { // Associative. - xml_test_rand_regression_formatter(size_t sd, size_t n, size_t m, - double tp, double ip, double ep, + xml_test_rand_regression_formatter(size_t sd, size_t n, size_t m, + double tp, double ip, double ep, double cp, double mp) { std::cout << make_xml_tag("sd", "value", sd); @@ -64,8 +64,8 @@ namespace __gnu_pbds } // Priority Queue. - xml_test_rand_regression_formatter(size_t sd, size_t n, size_t m, - double tp, double ip, double dp, + xml_test_rand_regression_formatter(size_t sd, size_t n, size_t m, + double tp, double ip, double dp, double ep, double cp, double mp) { std::cout << make_xml_tag("sd", "value", sd); @@ -83,16 +83,16 @@ namespace __gnu_pbds // Result formatter. struct xml_result_set_regression_formatter : public xml_result_set_formatter { - xml_result_set_regression_formatter(const std::string& r_container_name, + xml_result_set_regression_formatter(const std::string& r_container_name, const std::string& r_container_desc) : xml_result_set_formatter(r_container_name, r_container_desc) - { + { std::cout << detail::make_xml_name_start_tag("progress"); std::cout << detail::make_xml_name_start_tag_end_delimiter(); } ~xml_result_set_regression_formatter() - { std::cout << detail::make_xml_name_end_tag("progress"); } + { std::cout << detail::make_xml_name_end_tag("progress"); } }; } // namespace test } // namespace __gnu_pbds Index: libstdc++-v3/testsuite/util/regression/trait/assoc/native_type_trait.hpp =================================================================== --- libstdc++-v3/testsuite/util/regression/trait/assoc/native_type_trait.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/regression/trait/assoc/native_type_trait.hpp (working copy) @@ -104,7 +104,7 @@ namespace __gnu_pbds typedef std::map< Native_Key_Type, std::string> type; public: - static const typename type::key_type& + static const typename type::key_type& extract_key(typename type::const_reference r_val) { return (r_val.first); @@ -130,7 +130,7 @@ namespace __gnu_pbds typedef std::set< Native_Key_Type> type; public: - static const typename type::key_type& + static const typename type::key_type& extract_key(typename type::const_reference r_val) { return (r_val); Index: libstdc++-v3/testsuite/util/regression/trait/assoc/trait.hpp =================================================================== --- libstdc++-v3/testsuite/util/regression/trait/assoc/trait.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/regression/trait/assoc/trait.hpp (working copy) @@ -161,7 +161,7 @@ namespace detail native_value(const_reference r_val) { return native_type_traits_base::native_value(r_val); } - static const native_key_type& + static const native_key_type& extract_native_key(const native_value_type& r_val) { return native_type_traits_base::extract_key(r_val); } Index: libstdc++-v3/testsuite/util/regression/trait/assoc/type_trait.hpp =================================================================== --- libstdc++-v3/testsuite/util/regression/trait/assoc/type_trait.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/regression/trait/assoc/type_trait.hpp (working copy) @@ -74,7 +74,7 @@ namespace __gnu_pbds private: typedef typename cntnr::allocator_type::template rebind::other basic_type_rebind; - + typedef typename basic_type_rebind::const_reference basic_type_const_reference; typedef typename cntnr::allocator_type::template rebind >::other pair_type_rebind; @@ -92,7 +92,7 @@ namespace __gnu_pbds template static value_type - generate_value(Gen& gen, size_t max, + generate_value(Gen& gen, size_t max, std::pair) { return std::make_pair(basic_type(gen, max), basic_type(gen, max)); } @@ -108,4 +108,4 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/regression/trait/erase_if_fn.hpp =================================================================== --- libstdc++-v3/testsuite/util/regression/trait/erase_if_fn.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/regression/trait/erase_if_fn.hpp (working copy) @@ -47,7 +47,7 @@ namespace __gnu_pbds namespace detail { template - struct regression_test_erase_if_fn + struct regression_test_erase_if_fn : public std::unary_function { private: @@ -63,7 +63,7 @@ namespace __gnu_pbds }; template - struct regression_test_erase_if_fn > + struct regression_test_erase_if_fn > : public std::unary_function, bool> { private: @@ -82,4 +82,4 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/regression/trait/priority_queue/trait.hpp =================================================================== --- libstdc++-v3/testsuite/util/regression/trait/priority_queue/trait.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/regression/trait/priority_queue/trait.hpp (working copy) @@ -79,4 +79,4 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/replacement_memory_operators.h =================================================================== --- libstdc++-v3/testsuite/util/replacement_memory_operators.h (revision 235613) +++ libstdc++-v3/testsuite/util/replacement_memory_operators.h (working copy) @@ -31,7 +31,7 @@ namespace __gnu_test bool _M_throw; counter() : _M_count(0), _M_throw(true) { } - + ~counter() throw (counter_error) { if (_M_throw && _M_count != 0) @@ -45,12 +45,12 @@ namespace __gnu_test decrement() { get()._M_count--; } static counter& - get() + get() { static counter g; return g; } - + static std::size_t count() { return get()._M_count; } @@ -59,7 +59,7 @@ namespace __gnu_test }; template - bool + bool check_new(Alloc a = Alloc()) { __gnu_test::counter::exceptions(false); @@ -71,7 +71,7 @@ namespace __gnu_test } template - bool + bool check_delete(Alloc a = Alloc()) { __gnu_test::counter::exceptions(false); @@ -95,7 +95,7 @@ void* operator new(std::size_t size) throw(std::ba __gnu_test::counter::increment(); return p; } - + void operator delete(void* p) throw() { std::printf("operator delete is called \n"); @@ -104,7 +104,7 @@ void operator delete(void* p) throw() std::free(p); __gnu_test::counter::decrement(); - std::size_t count = __gnu_test::counter::count(); + std::size_t count = __gnu_test::counter::count(); if (count == 0) std::printf("All memory released \n"); else Index: libstdc++-v3/testsuite/util/statistic/result_recorder.hpp =================================================================== --- libstdc++-v3/testsuite/util/statistic/result_recorder.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/statistic/result_recorder.hpp (working copy) @@ -94,5 +94,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/statistic/sample_mean.hpp =================================================================== --- libstdc++-v3/testsuite/util/statistic/sample_mean.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/statistic/sample_mean.hpp (working copy) @@ -65,5 +65,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/statistic/sample_mean_confidence_checker.hpp =================================================================== --- libstdc++-v3/testsuite/util/statistic/sample_mean_confidence_checker.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/statistic/sample_mean_confidence_checker.hpp (working copy) @@ -58,8 +58,8 @@ namespace __gnu_pbds */ template bool - sample_mean_confidence_checker(Value_Type sm, Value_Type sv, - std::size_t num_samples, + sample_mean_confidence_checker(Value_Type sm, Value_Type sv, + std::size_t num_samples, double relative_interval) { enum @@ -80,5 +80,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/statistic/sample_variance.hpp =================================================================== --- libstdc++-v3/testsuite/util/statistic/sample_variance.hpp (revision 235613) +++ libstdc++-v3/testsuite/util/statistic/sample_variance.hpp (working copy) @@ -77,5 +77,5 @@ namespace __gnu_pbds } // namespace test } // namespace __gnu_pbds -#endif +#endif Index: libstdc++-v3/testsuite/util/testsuite_abi.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_abi.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_abi.h (working copy) @@ -31,12 +31,12 @@ struct symbol enum category { function, object, tls, uncategorized }; enum designation { existing, added, subtracted, undesignated }; enum version { none, compatible, incompatible, unversioned }; - enum compatibility - { - compat_type = 1, - compat_name = 2, - compat_size = 4, - compat_version = 8 + enum compatibility + { + compat_type = 1, + compat_name = 2, + compat_size = 4, + compat_version = 8 }; category type; @@ -48,13 +48,13 @@ struct symbol version version_status; designation status; - symbol() - : type(uncategorized), size(0), version_status(unversioned), + symbol() + : type(uncategorized), size(0), version_status(unversioned), status(undesignated) { } - symbol(const symbol& other) - : type(other.type), name(other.name), demangled_name(other.demangled_name), - size(other.size), version_name(other.version_name), + symbol(const symbol& other) + : type(other.type), name(other.name), demangled_name(other.demangled_name), + size(other.size), version_name(other.version_name), version_status(other.version_status), status(other.status) { } void @@ -72,7 +72,7 @@ typedef std::tr1::unordered_map // Blame subsequent hacks on Loren J. Rittle , Phil // Edwards , and a cast of dozens at libstdc++@gcc.gnu.org. - + #include "testsuite_abi.h" #include #include @@ -47,13 +47,13 @@ main(int argc, char** argv) << endl; exit(1); } - + if (argv1.find("--check") != string::npos) { bool verbose = false; if (argv1 == "--check-verbose") verbose = true; - + // Quick sanity/setup check for arguments. const char* test_file = argv[2]; const char* baseline_file = argv[3]; @@ -71,7 +71,7 @@ main(int argc, char** argv) if (!compare_symbols(baseline_file, test_file, verbose)) exit (1); } - + if (argv1 == "--examine") { const char* file = argv[3]; Index: libstdc++-v3/testsuite/util/testsuite_allocator.cc =================================================================== --- libstdc++-v3/testsuite/util/testsuite_allocator.cc (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_allocator.cc (working copy) @@ -25,11 +25,11 @@ namespace __gnu_test { typedef tracker_allocator_counter counter_type; - - counter_type::size_type + + counter_type::size_type counter_type::allocationCount_ = 0; - - counter_type::size_type + + counter_type::size_type counter_type::deallocationCount_ = 0; int counter_type::constructCount_ = 0; @@ -39,7 +39,7 @@ namespace __gnu_test check_construct_destroy(const char* tag, int expected_c, int expected_d) { bool ret = true; - if (counter_type::get_construct_count() != expected_c + if (counter_type::get_construct_count() != expected_c || counter_type::get_destruct_count() != expected_d) { std::cerr << tag << ": " Index: libstdc++-v3/testsuite/util/testsuite_allocator.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_allocator.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_allocator.h (working copy) @@ -37,7 +37,7 @@ namespace __gnu_test class tracker_allocator_counter { public: - typedef std::size_t size_type; + typedef std::size_t size_type; static void allocate(size_type blocksize) @@ -114,7 +114,7 @@ namespace __gnu_test typedef tracker_allocator::other> other; }; - + #if __cplusplus >= 201103L tracker_allocator() = default; tracker_allocator(const tracker_allocator&) = default; @@ -156,7 +156,7 @@ namespace __gnu_test #if __cplusplus >= 201103L template void - construct(U* p, Args&&... args) + construct(U* p, Args&&... args) { AllocTraits::construct(*this, p, std::forward(args)...); counter_type::construct(); @@ -201,12 +201,12 @@ namespace __gnu_test Alloc& aa = a; Alloc& ab = b; swap(aa, ab); - } + } }; template bool - operator==(const tracker_allocator& lhs, + operator==(const tracker_allocator& lhs, const tracker_allocator& rhs) throw() { const Alloc1& alloc1 = lhs; @@ -216,7 +216,7 @@ namespace __gnu_test template bool - operator!=(const tracker_allocator& lhs, + operator!=(const tracker_allocator& lhs, const tracker_allocator& rhs) throw() { return !(lhs == rhs); } @@ -235,7 +235,7 @@ namespace __gnu_test } template - bool + bool check_allocate_max_size() { Alloc a; @@ -316,7 +316,7 @@ namespace __gnu_test uneq_allocator(const uneq_allocator&) = default; uneq_allocator(uneq_allocator&&) = default; #endif - + template uneq_allocator(const uneq_allocator::other>& b) @@ -327,10 +327,10 @@ namespace __gnu_test { } int get_personality() const { return personality; } - + pointer allocate(size_type n, const void* hint = 0) - { + { pointer p = AllocTraits::allocate(*this, n); try @@ -387,7 +387,7 @@ namespace __gnu_test { std::swap(a.personality, b.personality); a.swap_base(b); - } + } template friend inline bool @@ -402,7 +402,7 @@ namespace __gnu_test const uneq_allocator::other>& b) { return !(a == b); } - + int personality; }; Index: libstdc++-v3/testsuite/util/testsuite_api.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_api.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_api.h (working copy) @@ -1,5 +1,5 @@ // -*- C++ -*- -// Exception testing utils for the C++ library testsuite. +// Exception testing utils for the C++ library testsuite. // // Copyright (C) 2007-2016 Free Software Foundation, Inc. // @@ -56,7 +56,7 @@ namespace __gnu_test : bad_non_virtual(), Exception("construct diamond") { } }; }; - + template struct diamond_derivation : diamond_derivation_base @@ -70,12 +70,12 @@ namespace __gnu_test // behavior is ambiguity. static void test() { - bool test __attribute__((unused)) = true; + bool test __attribute__((unused)) = true; try { throw error_type(); } catch (std::exception const&) { VERIFY( false ); } - catch (...) + catch (...) { VERIFY( true ); } } }; @@ -93,7 +93,7 @@ namespace __gnu_test { return *this; } #endif }; - + // See: 20.1.1 Template argument requirements. inline bool operator==(const NonDefaultConstructible&, const NonDefaultConstructible&) @@ -114,17 +114,17 @@ namespace __gnu_test // For 26 numeric algorithms requirements, need addable, // subtractable, multiplicable. inline NonDefaultConstructible - operator+(const NonDefaultConstructible& lhs, + operator+(const NonDefaultConstructible& lhs, const NonDefaultConstructible& rhs) { return NonDefaultConstructible(1); } inline NonDefaultConstructible - operator-(const NonDefaultConstructible& lhs, + operator-(const NonDefaultConstructible& lhs, const NonDefaultConstructible& rhs) { return NonDefaultConstructible(1); } inline NonDefaultConstructible - operator*(const NonDefaultConstructible& lhs, + operator*(const NonDefaultConstructible& lhs, const NonDefaultConstructible& rhs) { return NonDefaultConstructible(1); } @@ -133,7 +133,7 @@ namespace __gnu_test template struct void_function { - typedef _Result result_type; + typedef _Result result_type; result_type operator()() const @@ -143,7 +143,7 @@ namespace __gnu_test template<> struct void_function { - typedef NonDefaultConstructible result_type; + typedef NonDefaultConstructible result_type; result_type operator()() const @@ -152,7 +152,7 @@ namespace __gnu_test // For std::addressof, etc. struct OverloadedAddressAux { }; - + struct OverloadedAddress { OverloadedAddressAux Index: libstdc++-v3/testsuite/util/testsuite_character.cc =================================================================== --- libstdc++-v3/testsuite/util/testsuite_character.cc (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_character.cc (working copy) @@ -1,6 +1,6 @@ // -*- C++ -*- -// Utility subroutines for the C++ library testsuite. +// Utility subroutines for the C++ library testsuite. // // Copyright (C) 2002-2016 Free Software Foundation, Inc. // @@ -27,7 +27,7 @@ namespace std locale::id codecvt<__gnu_test::pod_uchar, char, __gnu_test::pod_state>::id; - locale::id + locale::id ctype<__gnu_test::pod_uchar>::id; locale::id @@ -36,7 +36,7 @@ namespace std locale::id moneypunct<__gnu_test::pod_uint>::id; - // Member specializations for the existing facet classes. + // Member specializations for the existing facet classes. // NB: This isn't especially portable. Perhaps a better way would be // to just specialize all of numpunct and ctype. using __gnu_test::pod_ushort; @@ -43,7 +43,7 @@ namespace std typedef pod_ushort::value_type value_type; template<> - bool + bool ctype:: do_is(mask, char_type) const { return true; } @@ -66,7 +66,7 @@ namespace std { return __lo; } template<> - pod_ushort + pod_ushort ctype:: do_toupper(char_type __c) const { return __c; } @@ -78,7 +78,7 @@ namespace std { return __hi; } template<> - pod_ushort + pod_ushort ctype:: do_tolower(char_type __c) const { return __c; } @@ -93,7 +93,7 @@ namespace std pod_ushort ctype:: do_widen(char __c) const - { + { char_type ret = { value_type(__c) }; return ret; } @@ -121,7 +121,7 @@ namespace std template<> const pod_ushort* ctype:: - do_narrow(const pod_ushort* __lo, const pod_ushort* __hi, + do_narrow(const pod_ushort* __lo, const pod_ushort* __hi, char, char* __dest) const { while (__lo < __hi) @@ -148,7 +148,7 @@ namespace std _M_data->_M_decimal_point.value = value_type('.'); _M_data->_M_thousands_sep.value = value_type(','); - + for (size_t i = 0; i < __num_base::_S_oend; ++i) { value_type v = __num_base::_S_atoms_out[i]; @@ -155,7 +155,7 @@ namespace std _M_data->_M_atoms_out[i].value = v; } _M_data->_M_atoms_out[__num_base::_S_oend] = pod_ushort(); - + for (size_t j = 0; j < __num_base::_S_iend; ++j) _M_data->_M_atoms_in[j].value = value_type(__num_base::_S_atoms_in[j]); _M_data->_M_atoms_in[__num_base::_S_iend] = pod_ushort(); Index: libstdc++-v3/testsuite/util/testsuite_character.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_character.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_character.h (working copy) @@ -31,7 +31,7 @@ #include namespace __gnu_test -{ +{ struct pod_int { int value; @@ -52,7 +52,7 @@ namespace __gnu_test inline bool operator==(const pod_int& lhs, const pod_int& rhs) { return lhs.value == rhs.value; } - + inline bool operator<(const pod_int& lhs, const pod_int& rhs) { return lhs.value < rhs.value; } @@ -68,7 +68,7 @@ namespace __gnu_test inline pod_int operator-(const pod_int& lhs, const pod_int& rhs) - { + { pod_int ret = { lhs.value - rhs.value }; return ret; } @@ -75,7 +75,7 @@ namespace __gnu_test inline pod_int operator*(const pod_int& lhs, const pod_int& rhs) - { + { pod_int ret = { lhs.value * rhs.value }; return ret; } @@ -98,10 +98,10 @@ namespace __gnu_test typedef character pod_char; typedef character pod_uchar; typedef character pod_ushort; - typedef character pod_uint; + typedef character pod_uint; } -namespace __gnu_cxx +namespace __gnu_cxx { // Specializations. // pod_char @@ -122,7 +122,7 @@ namespace __gnu_test V2 ret = { c.value }; return ret; } - + template<> template inline __gnu_test::pod_uchar::char_type @@ -160,7 +160,7 @@ namespace std // 3. tmp becomes the new value of state. template<> class codecvt<__gnu_test::pod_uchar, char, __gnu_test::pod_state> - : public __codecvt_abstract_base<__gnu_test::pod_uchar, char, + : public __codecvt_abstract_base<__gnu_test::pod_uchar, char, __gnu_test::pod_state> { public: @@ -303,7 +303,7 @@ namespace std ++from; continue; } - + if (max == 0) break; unsigned char tmp; @@ -390,7 +390,7 @@ namespace std do_widen(char c) const { return __gnu_test::pod_uchar::from(c); } - virtual const char* + virtual const char* do_widen(const char* low, const char* high, char_type* dest) const { transform(low, high, dest, &__gnu_test::pod_uchar::from); @@ -411,88 +411,88 @@ namespace std }; // numpunct specializations - template<> + template<> class numpunct<__gnu_test::pod_uint> : public locale::facet - { - public: - typedef __gnu_test::pod_uint char_type; - typedef basic_string string_type; - - static locale::id id; - + { + public: + typedef __gnu_test::pod_uint char_type; + typedef basic_string string_type; + + static locale::id id; + explicit numpunct(size_t refs = 0) - : locale::facet(refs) - { } - + : locale::facet(refs) + { } + char_type - decimal_point() const - { return this->do_decimal_point(); } - + decimal_point() const + { return this->do_decimal_point(); } + char_type - thousands_sep() const - { return this->do_thousands_sep(); } - + thousands_sep() const + { return this->do_thousands_sep(); } + string - grouping() const - { return this->do_grouping(); } - + grouping() const + { return this->do_grouping(); } + string_type - truename() const - { return this->do_truename(); } - + truename() const + { return this->do_truename(); } + string_type - falsename() const - { return this->do_falsename(); } - - protected: + falsename() const + { return this->do_falsename(); } + + protected: ~numpunct() - { } - + { } + virtual char_type - do_decimal_point() const - { return char_type(); } - + do_decimal_point() const + { return char_type(); } + virtual char_type - do_thousands_sep() const - { return char_type(); } - + do_thousands_sep() const + { return char_type(); } + virtual string - do_grouping() const - { return string(); } - + do_grouping() const + { return string(); } + virtual string_type - do_truename() const + do_truename() const { return string_type(); } - + virtual string_type - do_falsename() const - { return string_type(); } + do_falsename() const + { return string_type(); } }; - template<> + template<> class moneypunct<__gnu_test::pod_uint> : public locale::facet, public money_base - { - public: - typedef __gnu_test::pod_uint char_type; - typedef basic_string string_type; - - static locale::id id; + { + public: + typedef __gnu_test::pod_uint char_type; + typedef basic_string string_type; + + static locale::id id; static const bool intl = false; explicit moneypunct(size_t refs = 0) - : locale::facet(refs) + : locale::facet(refs) { } - + char_type - decimal_point() const - { return this->do_decimal_point(); } - + decimal_point() const + { return this->do_decimal_point(); } + char_type - thousands_sep() const + thousands_sep() const { return this->do_thousands_sep(); } string @@ -500,17 +500,17 @@ namespace std { return this->do_grouping(); } string_type - curr_symbol() const - { return this->do_curr_symbol(); } - + curr_symbol() const + { return this->do_curr_symbol(); } + string_type - positive_sign() const - { return this->do_positive_sign(); } + positive_sign() const + { return this->do_positive_sign(); } string_type - negative_sign() const - { return this->do_negative_sign(); } - + negative_sign() const + { return this->do_negative_sign(); } + int frac_digits() const { return this->do_frac_digits(); } @@ -518,39 +518,39 @@ namespace std pattern pos_format() const { return this->do_pos_format(); } - + pattern neg_format() const { return this->do_neg_format(); } - - protected: - ~moneypunct() - { } - + + protected: + ~moneypunct() + { } + virtual char_type - do_decimal_point() const - { return char_type(); } - + do_decimal_point() const + { return char_type(); } + virtual char_type - do_thousands_sep() const - { return char_type(); } - + do_thousands_sep() const + { return char_type(); } + virtual string - do_grouping() const + do_grouping() const { return string(); } virtual string_type - do_curr_symbol() const - { return string_type(); } - + do_curr_symbol() const + { return string_type(); } + string_type - do_positive_sign() const - { return string_type(); } + do_positive_sign() const + { return string_type(); } string_type - do_negative_sign() const - { return string_type(); } - + do_negative_sign() const + { return string_type(); } + int do_frac_digits() const { return 0; } @@ -558,7 +558,7 @@ namespace std pattern do_pos_format() const { return pattern(); } - + pattern do_neg_format() const { return pattern(); } Index: libstdc++-v3/testsuite/util/testsuite_common_types.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_common_types.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_common_types.h (working copy) @@ -1,5 +1,5 @@ // -*- C++ -*- -// typelist for the C++ library testsuite. +// typelist for the C++ library testsuite. // // Copyright (C) 2005-2016 Free Software Foundation, Inc. // @@ -276,10 +276,10 @@ namespace __gnu_test typedef char16_t a14; typedef char32_t a15; - typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, + typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)> type; #else - typedef node<_GLIBCXX_TYPELIST_CHAIN13(a1, a2, a3, a4, a5, a6, a7, a8, a9, + typedef node<_GLIBCXX_TYPELIST_CHAIN13(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)> type; #endif }; @@ -307,11 +307,11 @@ namespace __gnu_test __extension__ typedef __int128 a16; __extension__ typedef unsigned __int128 a17; - typedef node<_GLIBCXX_TYPELIST_CHAIN17(a1, a2, a3, a4, a5, a6, a7, a8, a9, + typedef node<_GLIBCXX_TYPELIST_CHAIN17(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17)> type; # else - typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, + typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)> type; # endif #else @@ -319,10 +319,10 @@ namespace __gnu_test __extension__ typedef __int128 a14; __extension__ typedef unsigned __int128 a15; - typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, + typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)> type; # else - typedef node<_GLIBCXX_TYPELIST_CHAIN13(a1, a2, a3, a4, a5, a6, a7, a8, a9, + typedef node<_GLIBCXX_TYPELIST_CHAIN13(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)> type; # endif #endif @@ -345,8 +345,8 @@ namespace __gnu_test typedef std::atomic_wchar_t a13; typedef std::atomic_char16_t a14; typedef std::atomic_char32_t a15; - - typedef node<_GLIBCXX_TYPELIST_CHAIN14(a2, a3, a4, a5, a6, a7, a8, a9, + + typedef node<_GLIBCXX_TYPELIST_CHAIN14(a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)> type; }; @@ -367,8 +367,8 @@ namespace __gnu_test typedef std::atomic_wchar_t a13; typedef std::atomic_char16_t a14; typedef std::atomic_char32_t a15; - - typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, + + typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)> type; }; @@ -395,7 +395,7 @@ namespace __gnu_test struct has_increment_operators { template - void + void operator()() { struct _Concept @@ -402,7 +402,7 @@ namespace __gnu_test { void __constraint() { - _Tp a; + _Tp a; ++a; // prefix a++; // postfix a += a; @@ -417,7 +417,7 @@ namespace __gnu_test struct has_decrement_operators { template - void + void operator()() { struct _Concept @@ -424,7 +424,7 @@ namespace __gnu_test { void __constraint() { - _Tp a; + _Tp a; --a; // prefix a--; // postfix a -= a; @@ -486,7 +486,7 @@ namespace __gnu_test struct has_bitwise_operators { template - void + void operator()() { struct _Concept @@ -511,7 +511,7 @@ namespace __gnu_test struct constexpr_comparison_eq_ne { template - void + void operator()() { static_assert(_Tp1() == _Tp2(), "eq"); @@ -522,7 +522,7 @@ namespace __gnu_test struct constexpr_comparison_operators { template - void + void operator()() { static_assert(!(_Tp() < _Tp()), "less"); @@ -538,7 +538,7 @@ namespace __gnu_test struct has_trivial_cons_dtor { template - void + void operator()() { struct _Concept @@ -561,7 +561,7 @@ namespace __gnu_test struct standard_layout { template - void + void operator()() { struct _Concept @@ -583,7 +583,7 @@ namespace __gnu_test struct has_required_base_class { template - void + void operator()() { struct _Concept @@ -593,7 +593,7 @@ namespace __gnu_test const _TDerived& obj = __a; const _TBase* base __attribute__((unused)) = &obj; } - + _TDerived __a; }; @@ -606,7 +606,7 @@ namespace __gnu_test struct assignable { template - void + void operator()() { struct _Concept @@ -627,7 +627,7 @@ namespace __gnu_test struct default_constructible { template - void + void operator()() { struct _Concept @@ -645,7 +645,7 @@ namespace __gnu_test struct copy_constructible { template - void + void operator()() { struct _Concept @@ -665,7 +665,7 @@ namespace __gnu_test struct single_value_constructible { template - void + void operator()() { struct _Concept @@ -672,7 +672,7 @@ namespace __gnu_test { void __constraint() { _Ttype __v(__a); } - + _Tvalue __a; }; @@ -708,7 +708,7 @@ namespace __gnu_test }; template - void + void operator()() { _Concept<_Tp> c; @@ -736,7 +736,7 @@ namespace __gnu_test struct constexpr_single_value_constructible { - template::value> struct _Concept; @@ -760,7 +760,7 @@ namespace __gnu_test struct _Concept<_Ttesttype, _Tvaluetype, false> { void __constraint() - { + { const _Tvaluetype __v { }; static _Ttesttype __obj(__v); } @@ -781,17 +781,17 @@ namespace __gnu_test struct direct_list_initializable { template - void + void operator()() { struct _Concept { void __constraint() - { + { _Ttype __v1 { }; // default ctor _Ttype __v2 { __a }; // single-argument ctor } - + _Tvalue __a; }; @@ -805,7 +805,7 @@ namespace __gnu_test struct copy_list_initializable { template - void + void operator()() { struct _Concept @@ -812,7 +812,7 @@ namespace __gnu_test { void __constraint() { _Ttype __v __attribute__((unused)) = {__a}; } - + _Tvalue __a; }; @@ -825,7 +825,7 @@ namespace __gnu_test struct integral_convertable { template - void + void operator()() { struct _Concept @@ -847,11 +847,11 @@ namespace __gnu_test } }; - // Generator to test integral assignment operator + // Generator to test integral assignment operator struct integral_assignable { template - void + void operator()() { struct _Concept Index: libstdc++-v3/testsuite/util/testsuite_containergen.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_containergen.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_containergen.h (working copy) @@ -62,7 +62,7 @@ namespace __gnu_test test_containers(Tester test) { std::mt19937_64 random_gen; - + #ifdef SIMULATOR_TEST int loops = 10; #else @@ -75,7 +75,7 @@ namespace __gnu_test for(int i = 1; i < 100; ++i) for(int j = 0; j < loops; ++j) test_single_container(test, random_gen, i, i); - + for(int i = 0; i < loops; ++i) { test_single_container(test, random_gen, 10, 10); Index: libstdc++-v3/testsuite/util/testsuite_containers.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_containers.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_containers.h (working copy) @@ -225,34 +225,34 @@ namespace __gnu_test // DR 130 vs. C++98 vs. C++11. // Defined in testsuite_shared.cc. - void + void erase_external(std::set& s); - void + void erase_external(std::multiset& s); - void + void erase_external(std::map& s); - void + void erase_external(std::multimap& s); - void + void erase_external_iterators(std::set& s); - void + void erase_external_iterators(std::multiset& s); - void + void erase_external_iterators(std::map& s); - void + void erase_external_iterators(std::multimap& s); // NB: "must be compiled with C++11" #if __cplusplus >= 201103L template - void + void linkage_check_cxx98_cxx11_erase(_Tp& container) { // Crashing when external reference and internal reference symbols are @@ -263,7 +263,7 @@ template } template - void + void linkage_check_cxx98_cxx11_erase_iterators(_Tp& container) { // Crashing when external reference and internal reference symbols are Index: libstdc++-v3/testsuite/util/testsuite_counter_type.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_counter_type.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_counter_type.h (working copy) @@ -39,7 +39,7 @@ namespace __gnu_test static int destructor_count; int val; - + counter_type() : val(0) { ++default_count; } Index: libstdc++-v3/testsuite/util/testsuite_error.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_error.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_error.h (working copy) @@ -1,5 +1,5 @@ // -*- C++ -*- -// Error handling utils for the C++ library testsuite. +// Error handling utils for the C++ library testsuite. // // Copyright (C) 2007-2016 Free Software Foundation, Inc. // @@ -28,7 +28,7 @@ namespace __gnu_test { struct test_category : public std::error_category - { + { virtual const char* name() const noexcept { @@ -36,13 +36,13 @@ namespace __gnu_test return s; } - virtual std::string + virtual std::string message(int) const { return std::string("message to be determined"); } }; struct test_derived_category : public test_category - { + { virtual const char* name() const noexcept { Index: libstdc++-v3/testsuite/util/testsuite_hooks.cc =================================================================== --- libstdc++-v3/testsuite/util/testsuite_hooks.cc (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_hooks.cc (working copy) @@ -1,6 +1,6 @@ // -*- C++ -*- -// Utility subroutines for the C++ library testsuite. +// Utility subroutines for the C++ library testsuite. // // Copyright (C) 2002-2016 Free Software Foundation, Inc. // @@ -53,7 +53,7 @@ namespace __gnu_test { #ifdef _GLIBCXX_RES_LIMITS - void + void set_memory_limits(float size) { struct rlimit r; @@ -105,10 +105,10 @@ namespace __gnu_test #else void set_memory_limits(float) { } -#endif +#endif #ifdef _GLIBCXX_RES_LIMITS - void + void set_file_limit(unsigned long size) { #if _GLIBCXX_HAVE_LIMIT_FSIZE @@ -125,9 +125,9 @@ namespace __gnu_test #else void set_file_limit(unsigned long) { } -#endif +#endif - void + void verify_demangle(const char* mangled, const char* wanted) { int status = 0; @@ -158,12 +158,12 @@ namespace __gnu_test std::__throw_runtime_error(s); } - void + void run_tests_wrapped_locale(const char* name, const func_callback& l) { using namespace std; - - // Set the global locale. + + // Set the global locale. locale loc_name = locale(name); locale orig = locale::global(loc_name); @@ -184,19 +184,19 @@ namespace __gnu_test __throw_runtime_error(s.c_str()); } } - - void + + void run_tests_wrapped_env(const char* name, const char* env, const func_callback& l) { using namespace std; - -#ifdef _GLIBCXX_HAVE_SETENV - // Set the global locale. + +#ifdef _GLIBCXX_HAVE_SETENV + // Set the global locale. locale loc_name = locale(name); locale orig = locale::global(loc_name); - // Set environment variable env to value in name. + // Set environment variable env to value in name. const char* oldENV = getenv(env); if (!setenv(env, name, 1)) { @@ -226,7 +226,7 @@ namespace __gnu_test #ifdef _GLIBCXX_SYSV_SEM // This union is not declared in system headers. Instead, it must // be defined by user programs. - union semun + union semun { int val; struct semid_ds *buf; @@ -234,7 +234,7 @@ namespace __gnu_test }; #endif - semaphore::semaphore() + semaphore::semaphore() { #ifdef _GLIBCXX_SYSV_SEM // Remember the PID for the process that created the semaphore set @@ -245,7 +245,7 @@ namespace __gnu_test #ifndef SEM_R #define SEM_R 0400 #endif - + #ifndef SEM_A #define SEM_A 0200 #endif @@ -268,12 +268,12 @@ namespace __gnu_test #endif } - semaphore::~semaphore() + semaphore::~semaphore() { #ifdef _GLIBCXX_SYSV_SEM union semun val; val.val = 0; // Avoid uninitialized variable warning. - // Destroy the semaphore set only in the process that created it. + // Destroy the semaphore set only in the process that created it. if (pid_ == getpid()) semctl(sem_set_, 0, IPC_RMID, val); #endif @@ -280,10 +280,10 @@ namespace __gnu_test } void - semaphore::signal() + semaphore::signal() { #ifdef _GLIBCXX_SYSV_SEM - struct sembuf op[1] = + struct sembuf op[1] = { { 0, 1, 0 } }; @@ -293,16 +293,16 @@ namespace __gnu_test } void - semaphore::wait() + semaphore::wait() { #ifdef _GLIBCXX_SYSV_SEM - struct sembuf op[1] = + struct sembuf op[1] = { { 0, -1, SEM_UNDO } }; if (semop(sem_set_, op, 1) == -1) std::__throw_runtime_error("could not wait for semaphore"); -#endif +#endif } // For use in 22_locale/time_get and time_put. Index: libstdc++-v3/testsuite/util/testsuite_hooks.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_hooks.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_hooks.h (working copy) @@ -1,5 +1,5 @@ // -*- C++ -*- -// Utility subroutines for the C++ library testsuite. +// Utility subroutines for the C++ library testsuite. // // Copyright (C) 2000-2016 Free Software Foundation, Inc. // @@ -99,7 +99,7 @@ namespace __gnu_test // Simple callback structure for variable numbers of tests (all with // same signature). Assume all unit tests are of the signature - // void test01(); + // void test01(); class func_callback { public: @@ -133,11 +133,11 @@ namespace __gnu_test // Run select unit tests after setting global locale. - void + void run_tests_wrapped_locale(const char*, const func_callback&); // Run select unit tests after setting environment variables. - void + void run_tests_wrapped_env(const char*, const char*, const func_callback&); // Counting. @@ -152,9 +152,9 @@ namespace __gnu_test object_counter (const object_counter&) { ++count; } ~object_counter() { --count; } }; - + #define assert_count(n) VERIFY(__gnu_test::object_counter::count == n) - + // A (static) class for counting copy constructors and possibly throwing an // exception on a desired count. class copy_constructor @@ -162,7 +162,7 @@ namespace __gnu_test public: static unsigned int count() { return count_; } - + static void mark_call() { @@ -170,7 +170,7 @@ namespace __gnu_test if (count_ == throw_on_) std::__throw_runtime_error("copy_constructor::mark_call"); } - + static void reset() { @@ -177,7 +177,7 @@ namespace __gnu_test count_ = 0; throw_on_ = 0; } - + static void throw_on(unsigned int count) { throw_on_ = count; } @@ -185,7 +185,7 @@ namespace __gnu_test static unsigned int count_; static unsigned int throw_on_; }; - + // A (static) class for counting assignment operator calls and // possibly throwing an exception on a desired count. class assignment_operator @@ -193,7 +193,7 @@ namespace __gnu_test public: static unsigned int count() { return count_; } - + static void mark_call() { @@ -216,7 +216,7 @@ namespace __gnu_test static unsigned int count_; static unsigned int throw_on_; }; - + // A (static) class for tracking calls to an object's destructor. class destructor { @@ -223,7 +223,7 @@ namespace __gnu_test public: static unsigned int count() { return _M_count; } - + static void mark_call() { _M_count++; } @@ -233,7 +233,7 @@ namespace __gnu_test private: static unsigned int _M_count; }; - + // An class of objects that can be used for validating various // behaviours and guarantees of containers and algorithms defined in // the standard library. @@ -262,7 +262,7 @@ namespace __gnu_test // copied, well, make it so. copy_tracker& operator=(const copy_tracker& rhs) - { + { id_ = rhs.id(); if (rhs.throw_on_copy_) assignment_operator::throw_on(assignment_operator::count() + 1); @@ -299,12 +299,12 @@ namespace __gnu_test { return lhs.id() < rhs.id(); } // Class for checking required type conversions, implicit and - // explicit for given library data structures. + // explicit for given library data structures. template struct conversion { typedef typename _Container::const_iterator const_iterator; - + // Implicit conversion iterator to const_iterator. static const_iterator iterator_to_const_iterator() @@ -317,11 +317,11 @@ namespace __gnu_test }; // A binary semaphore for use across multiple processes. - class semaphore + class semaphore { public: // Creates a binary semaphore. The semaphore is initially in the - // unsignaled state. + // unsignaled state. semaphore(); // Destroy the semaphore. Index: libstdc++-v3/testsuite/util/testsuite_io.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_io.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_io.h (working copy) @@ -25,9 +25,9 @@ #include namespace __gnu_test -{ +{ // Used to verify the constraints/requirements on get and put areas - // as defined in + // as defined in // 27.5.1 - Stream buffer requirements: get and put areas // 27.8.1.1 - Template class basic_filebuf p 3 // If the file is not open (ios_base::in) -> input seq. cannot be read @@ -44,29 +44,29 @@ namespace __gnu_test { public: bool - write_position() - { - bool one = this->pptr() != 0; + write_position() + { + bool one = this->pptr() != 0; bool two = this->pptr() < this->epptr(); return one && two; } - + bool read_position() - { - bool one = this->gptr() != 0; + { + bool one = this->gptr() != 0; bool two = this->gptr() < this->egptr(); return one && two; } - + bool - unbuffered() - { - bool one = this->pbase() == 0; - bool two = this->pptr() == 0; + unbuffered() + { + bool one = this->pbase() == 0; + bool two = this->pptr() == 0; return one && two; } - + bool check_pointers() { @@ -73,7 +73,7 @@ namespace __gnu_test bool one = this->eback() == 0; bool two = this->gptr() == 0; bool three = this->egptr() == 0; - + bool four = this->pbase() == 0; bool five = this->pptr() == 0; bool six = this->epptr() == 0; @@ -99,12 +99,12 @@ namespace __gnu_test { private: bool m_sync_called; - + public: sync_buf() : m_sync_called(false) { } - + bool sync_called() const { return m_sync_called; } @@ -146,18 +146,18 @@ namespace __gnu_test this->setg(p, p, p + 1); } - virtual int_type underflow() + virtual int_type underflow() { throw underflow_error(); return int_type(); } - - virtual int_type uflow() + + virtual int_type uflow() { throw underflow_error(); return int_type(); } - + virtual int_type overflow(int_type) { @@ -164,26 +164,26 @@ namespace __gnu_test throw overflow_error(); return int_type(); } - - virtual pos_type + + virtual pos_type seekoff(off_type, std::ios_base::seekdir, std::ios_base::openmode) - { + { throw positioning_error(); - return pos_type(off_type(-1)); - } - - virtual pos_type + return pos_type(off_type(-1)); + } + + virtual pos_type seekpos(pos_type, std::ios_base::openmode) - { + { throw positioning_error(); - return pos_type(off_type(-1)); - } - - virtual int - sync() - { + return pos_type(off_type(-1)); + } + + virtual int + sync() + { throw positioning_error(); - return 0; + return 0; } }; @@ -203,58 +203,58 @@ namespace __gnu_test typedef typename std::num_get::iter_type iter_type; protected: - iter_type + iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const { throw facet_error(); return iter_type(); } - virtual iter_type + virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const { throw facet_error(); return iter_type(); } - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, unsigned short&) const { throw facet_error(); return iter_type(); } - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, unsigned int&) const { throw facet_error(); return iter_type(); } - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, unsigned long&) const { throw facet_error(); return iter_type(); } -#ifdef _GLIBCXX_USE_LONG_LONG - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, +#ifdef _GLIBCXX_USE_LONG_LONG + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long long&) const { throw facet_error(); return iter_type(); } - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, unsigned long long&) const { throw facet_error(); return iter_type(); } #endif - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const { throw facet_error(); return iter_type(); } - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, double&) const { throw facet_error(); return iter_type(); } - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long double&) const { throw facet_error(); return iter_type(); } - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const { throw facet_error(); return iter_type(); } }; @@ -273,37 +273,37 @@ namespace __gnu_test typedef typename std::num_put::char_type char_type; protected: - iter_type + iter_type do_put(iter_type, ios_base&, char_type, bool) const { throw facet_error(); return iter_type(0); } - - virtual iter_type + + virtual iter_type do_put(iter_type, ios_base&, char_type, long) const { throw facet_error(); return iter_type(0); } - virtual iter_type + virtual iter_type do_put(iter_type, ios_base&, char_type, unsigned long) const { throw facet_error(); return iter_type(0); } -#ifdef _GLIBCXX_USE_LONG_LONG - virtual iter_type +#ifdef _GLIBCXX_USE_LONG_LONG + virtual iter_type do_put(iter_type, ios_base&, char_type, long long) const { throw facet_error(); return iter_type(0); } - virtual iter_type + virtual iter_type do_put(iter_type, ios_base&, char_type, unsigned long long) const { throw facet_error(); return iter_type(0); } #endif - - virtual iter_type + + virtual iter_type do_put(iter_type, ios_base&, char_type, double) const { throw facet_error(); return iter_type(0); } - virtual iter_type + virtual iter_type do_put(iter_type, ios_base&, char_type, long double) const { throw facet_error(); return iter_type(0); } - - virtual iter_type + + virtual iter_type do_put(iter_type, ios_base&, char_type, const void*) const { throw facet_error(); return iter_type(0); } }; Index: libstdc++-v3/testsuite/util/testsuite_iterators.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_iterators.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_iterators.h (working copy) @@ -1,5 +1,5 @@ // -*- C++ -*- -// Iterator Wrappers for the C++ library testsuite. +// Iterator Wrappers for the C++ library testsuite. // // Copyright (C) 2004-2016 Free Software Foundation, Inc. // @@ -113,7 +113,7 @@ namespace __gnu_test /** * @brief output_iterator wrapper for pointer - * + * * This class takes a pointer and wraps it to provide exactly * the requirements of a output_iterator. It should not be * instantiated directly, but generated from a test_container @@ -131,7 +131,7 @@ namespace __gnu_test { ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last); } - + output_iterator_wrapper(const output_iterator_wrapper& in) : ptr(in.ptr), SharedInfo(in.SharedInfo) { } @@ -143,9 +143,9 @@ namespace __gnu_test ITERATOR_VERIFY(SharedInfo->writtento[ptr - SharedInfo->first] == false); return WritableObject(ptr, SharedInfo); } - + output_iterator_wrapper& - operator=(const output_iterator_wrapper& in) + operator=(const output_iterator_wrapper& in) { ptr = in.ptr; SharedInfo = in.SharedInfo; @@ -182,7 +182,7 @@ namespace __gnu_test /** * @brief input_iterator wrapper for pointer - * + * * This class takes a pointer and wraps it to provide exactly * the requirements of a input_iterator. It should not be * instantiated directly, but generated from a test_container @@ -203,7 +203,7 @@ namespace __gnu_test input_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) : ptr(_ptr), SharedInfo(SharedInfo_in) { ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last); } - + input_iterator_wrapper(const input_iterator_wrapper& in) : ptr(in.ptr), SharedInfo(in.SharedInfo) { } @@ -273,7 +273,7 @@ namespace __gnu_test /** * @brief forward_iterator wrapper for pointer - * + * * This class takes a pointer and wraps it to provide exactly * the requirements of a forward_iterator. It should not be * instantiated directly, but generated from a test_container @@ -286,7 +286,7 @@ namespace __gnu_test forward_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) : input_iterator_wrapper(_ptr, SharedInfo_in) { } - + forward_iterator_wrapper(const forward_iterator_wrapper& in) : input_iterator_wrapper(in) { } @@ -327,7 +327,7 @@ namespace __gnu_test /** * @brief bidirectional_iterator wrapper for pointer - * + * * This class takes a pointer and wraps it to provide exactly * the requirements of a forward_iterator. It should not be * instantiated directly, but generated from a test_container @@ -355,7 +355,7 @@ namespace __gnu_test this->SharedInfo = in.SharedInfo; return *this; } - + bidirectional_iterator_wrapper& operator++() { @@ -372,7 +372,7 @@ namespace __gnu_test return tmp; } - bidirectional_iterator_wrapper& + bidirectional_iterator_wrapper& operator--() { ITERATOR_VERIFY(this->SharedInfo && this->ptr > this->SharedInfo->first); @@ -382,7 +382,7 @@ namespace __gnu_test bidirectional_iterator_wrapper operator--(int) - { + { bidirectional_iterator_wrapper tmp = *this; --*this; return tmp; @@ -391,13 +391,13 @@ namespace __gnu_test /** * @brief random_access_iterator wrapper for pointer - * + * * This class takes a pointer and wraps it to provide exactly * the requirements of a forward_iterator. It should not be * instantiated directly, but generated from a test_container */ template - struct random_access_iterator_wrapper + struct random_access_iterator_wrapper : public bidirectional_iterator_wrapper { typedef BoundsContainer ContainerType; @@ -510,7 +510,7 @@ namespace __gnu_test return !(*this < in); } - bool + bool operator<=(const random_access_iterator_wrapper& in) const { return !(*this > in); @@ -524,15 +524,15 @@ namespace __gnu_test template random_access_iterator_wrapper - operator+(std::ptrdiff_t n, random_access_iterator_wrapper it) + operator+(std::ptrdiff_t n, random_access_iterator_wrapper it) { return it += n; } - /** + /** * @brief A container-type class for holding iterator wrappers * test_container takes two parameters, a class T and an iterator * wrapper templated by T (for example forward_iterator_wrapper. - * It takes two pointers representing a range and presents them as + * It takes two pointers representing a range and presents them as * a container of iterators. */ template class ItType> Index: libstdc++-v3/testsuite/util/testsuite_new_operators.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_new_operators.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_new_operators.h (working copy) @@ -1,5 +1,5 @@ // -*- C++ -*- -// Utility subroutines for the C++ library testsuite. +// Utility subroutines for the C++ library testsuite. // // Copyright (C) 2000-2016 Free Software Foundation, Inc. // Index: libstdc++-v3/testsuite/util/testsuite_performance.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_performance.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_performance.h (working copy) @@ -85,7 +85,7 @@ namespace __gnu_test time_counter() : elapsed_begin(), elapsed_end(), tms_begin(), tms_end() { } - void + void clear() throw() { elapsed_begin = clock_t(); @@ -96,18 +96,18 @@ namespace __gnu_test void start() - { + { this->clear(); - elapsed_begin = times(&tms_begin); + elapsed_begin = times(&tms_begin); const clock_t err = clock_t(-1); if (elapsed_begin == err) std::__throw_runtime_error("time_counter::start"); } - + void stop() - { - elapsed_end = times(&tms_end); + { + elapsed_end = times(&tms_end); const clock_t err = clock_t(-1); if (elapsed_end == err) std::__throw_runtime_error("time_counter::stop"); @@ -137,28 +137,28 @@ namespace __gnu_test public: resource_counter(int i = RUSAGE_SELF) : who(i) { this->clear(); } - - void + + void clear() throw() - { - memset(&rusage_begin, 0, sizeof(rusage_begin)); - memset(&rusage_end, 0, sizeof(rusage_end)); - memset(&allocation_begin, 0, sizeof(allocation_begin)); - memset(&allocation_end, 0, sizeof(allocation_end)); + { + memset(&rusage_begin, 0, sizeof(rusage_begin)); + memset(&rusage_end, 0, sizeof(rusage_end)); + memset(&allocation_begin, 0, sizeof(allocation_begin)); + memset(&allocation_end, 0, sizeof(allocation_end)); } void start() - { + { if (getrusage(who, &rusage_begin) != 0 ) memset(&rusage_begin, 0, sizeof(rusage_begin)); malloc(0); // Needed for some implementations. allocation_begin = mallinfo(); } - + void stop() - { + { if (getrusage(who, &rusage_end) != 0 ) memset(&rusage_end, 0, sizeof(rusage_end)); allocation_end = mallinfo(); @@ -168,12 +168,12 @@ namespace __gnu_test allocated_memory() const { return ((allocation_end.uordblks - allocation_begin.uordblks) + (allocation_end.hblkhd - allocation_begin.hblkhd)); } - - long + + long hard_page_fault() const { return rusage_end.ru_majflt - rusage_begin.ru_majflt; } - long + long swapped() const { return rusage_end.ru_nswap - rusage_begin.ru_nswap; } }; @@ -200,7 +200,7 @@ namespace __gnu_test } void - report_performance(const std::string file, const std::string comment, + report_performance(const std::string file, const std::string comment, const time_counter& t, const resource_counter& r) { const char space = ' '; @@ -226,7 +226,7 @@ namespace __gnu_test out << std::setw(4) << t.system_time() << "s" << space; out << std::setw(8) << r.allocated_memory() << "mem" << space; out << std::setw(4) << r.hard_page_fault() << "pf" << space; - + out << std::endl; out.close(); } @@ -273,7 +273,7 @@ template'; #endif - + titlename += ".title"; std::ofstream titlefile(titlename.c_str()); if (!titlefile.good()) @@ -301,7 +301,7 @@ template struct value_type : public std::pair { - inline value_type& operator++() - { + inline value_type& operator++() + { ++this->second; - return *this; + return *this; } - + inline operator TestType() const { return this->second; } }; @@ -410,7 +410,7 @@ template, 0); pthread_create(&t3, 0, &do_thread, 0); pthread_create(&t4, 0, &do_thread, 0); - + pthread_join(t1, 0); pthread_join(t2, 0); pthread_join(t3, 0); @@ -445,7 +445,7 @@ template operator()(Container) { const int i = 20000; - test_container(_M_filename); + test_container(_M_filename); } private: @@ -461,7 +461,7 @@ sequence_find_container(std::string& type) std::string::size_type n2 = type.find("list"); std::string::size_type n3 = type.find("deque"); std::string::size_type n4 = type.find("string"); - + if (n1 != npos || n2 != npos || n3 != npos || n4 != npos) return std::min(std::min(n1, n2), std::min(n3, n4)); else Index: libstdc++-v3/testsuite/util/testsuite_random.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_random.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_random.h (working copy) @@ -149,7 +149,7 @@ namespace __gnu_test double f = std::lgamma(k + (double)n); double a = std::lgamma(n); double b = std::lgamma(k + 1.0); - + return std::exp(f - a - b) * std::pow(p, n) * std::pow(1 - p, k); } } @@ -161,7 +161,7 @@ namespace __gnu_test return 0.0; else { - double lf = std::lgamma(k + 1.0); + double lf = std::lgamma(k + 1.0); return std::exp(std::log(mu) * k - lf - mu); } } Index: libstdc++-v3/testsuite/util/testsuite_regex.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_regex.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_regex.h (working copy) @@ -106,7 +106,7 @@ namespace __gnu_test show_regex_error_codes(); cout << "regex_error::code " << regex_error_codes[e.code()] << endl; - + if (__error != regex_error_internal) { // Then expected error_type is __error. Check. Index: libstdc++-v3/testsuite/util/testsuite_rng.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_rng.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_rng.h (working copy) @@ -48,7 +48,7 @@ namespace __gnu_pbds class twister_rand_gen { public: - twister_rand_gen(unsigned int seed = + twister_rand_gen(unsigned int seed = static_cast(std::time(0))) : m_base_generator(seed) { @@ -64,7 +64,7 @@ namespace __gnu_pbds { return(static_cast(std::time(0))); } unsigned long - get_unsigned_long(unsigned long min = 0, + get_unsigned_long(unsigned long min = 0, unsigned long max = UINT_MAX - 1) { _GLIBCXX_DEBUG_ASSERT(max >= min); Index: libstdc++-v3/testsuite/util/testsuite_rvalref.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_rvalref.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_rvalref.h (working copy) @@ -43,7 +43,7 @@ namespace __gnu_test rvalstruct& operator=(int newval) - { + { val = newval; valid = true; return *this; @@ -76,7 +76,7 @@ namespace __gnu_test } }; - inline bool + inline bool operator==(const rvalstruct& lhs, const rvalstruct& rhs) { return lhs.val == rhs.val; } @@ -103,7 +103,7 @@ namespace __gnu_test static int copycount; int val; bool valid; - + copycounter() : val(0), valid(true) { } @@ -125,10 +125,10 @@ namespace __gnu_test in.valid = false; valid = true; } - + copycounter& operator=(int newval) - { + { val = newval; valid = true; return *this; @@ -135,7 +135,7 @@ namespace __gnu_test } bool - operator=(const copycounter& in) + operator=(const copycounter& in) { bool test __attribute__((unused)) = true; VERIFY( in.valid == true ); @@ -155,13 +155,13 @@ namespace __gnu_test valid = true; return *this; } - + ~copycounter() noexcept { valid = false; } }; int copycounter::copycount = 0; - + inline bool operator==(const copycounter& lhs, const copycounter& rhs) { return lhs.val == rhs.val; } Index: libstdc++-v3/testsuite/util/testsuite_shared.cc =================================================================== --- libstdc++-v3/testsuite/util/testsuite_shared.cc (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_shared.cc (working copy) @@ -34,7 +34,7 @@ try_allocation() typedef __gnu_cxx::__mt_alloc allocator_t; - typedef std::char_traits traits_t; + typedef std::char_traits traits_t; typedef std::basic_string string_t; string_t s; @@ -42,7 +42,7 @@ try_allocation() } // libstdc++/23591 -extern "C" void +extern "C" void try_throw_exception() { try @@ -53,7 +53,7 @@ try_throw_exception() { } } -extern "C" void +extern "C" void try_function_random_fail() { long seed = lrand48(); @@ -77,23 +77,23 @@ try_function_random_fail() #if __cplusplus < 201103L // "must be compiled with C++98" - void + void erase_external(std::set& s) { s.erase(s.begin()); } - void + void erase_external(std::multiset& s) { s.erase(s.begin()); } - - void + + void erase_external(std::map& s) { s.erase(s.begin()); } - - void + + void erase_external(std::multimap& s) { s.erase(s.begin()); } - void + void erase_external_iterators(std::set& s) { typedef typename std::set::iterator iterator_type; @@ -101,7 +101,7 @@ try_function_random_fail() s.erase(iter, ++iter); } - void + void erase_external_iterators(std::multiset& s) { typedef typename std::multiset::iterator iterator_type; @@ -109,7 +109,7 @@ try_function_random_fail() s.erase(iter, ++iter); } - void + void erase_external_iterators(std::map& s) { typedef typename std::map::iterator iterator_type; @@ -117,8 +117,8 @@ try_function_random_fail() s.erase(iter, ++iter); } - - void + + void erase_external_iterators(std::multimap& s) { typedef typename std::multimap::iterator iterator_type; Index: libstdc++-v3/testsuite/util/testsuite_tr1.h =================================================================== --- libstdc++-v3/testsuite/util/testsuite_tr1.h (revision 235613) +++ libstdc++-v3/testsuite/util/testsuite_tr1.h (working copy) @@ -535,32 +535,32 @@ namespace __gnu_test { struct E {}; - + struct NTD1 { ~NTD1() = default; }; - + struct NTD2 { ~NTD2(); }; - + struct NTD3 { ~NTD3() throw(); }; - + struct TD1 { ~TD1() noexcept(false); }; - + struct TD2 { ~TD2() throw(int); }; - + struct Aggr { int i; @@ -567,7 +567,7 @@ namespace __gnu_test bool b; E e; }; - + struct Aggr2 { int i; @@ -574,28 +574,28 @@ namespace __gnu_test bool b; TD1 r; }; - + struct Del { ~Del() = delete; }; - + struct Del2 { ~Del2() noexcept = delete; }; - + struct Del3 { ~Del3() noexcept(false) = delete; }; - + struct Der : Aggr {}; - + struct Der2 : Aggr2 {}; - + union U1 { int i; @@ -603,7 +603,7 @@ namespace __gnu_test void* p; TD1* pt; }; - + union Ut { int i; @@ -611,7 +611,7 @@ namespace __gnu_test void* p; TD1 pt; }; - + enum class En { a, b, c, d }; enum En2 { En2a, En2b, En2c, En2d }; @@ -622,7 +622,7 @@ namespace __gnu_test { virtual ~Abstract1() = 0; }; - + struct AbstractDelDtor { ~AbstractDelDtor() = delete; @@ -633,7 +633,7 @@ namespace __gnu_test { virtual ~Abstract2() noexcept(false) = 0; }; - + struct Abstract3 { ~Abstract3() noexcept(false); @@ -679,7 +679,7 @@ namespace __gnu_test DelCopy(const DelCopy&) = delete; }; } - + namespace assign { struct Empty {}; Index: libstdc++-v3/testsuite/util/thread/all.h =================================================================== --- libstdc++-v3/testsuite/util/thread/all.h (revision 235613) +++ libstdc++-v3/testsuite/util/thread/all.h (working copy) @@ -28,7 +28,7 @@ // C++0x only. namespace __gnu_test -{ +{ // Assume _Tp::native_handle_type. // Check C++ to native_handle_type characteristics: size and alignment. template @@ -42,7 +42,7 @@ namespace __gnu_test typedef typename std::remove_pointer::type native_type; int st = sizeof(test_type); - int snt = sizeof(native_type); + int snt = sizeof(native_type); int at = __alignof__(test_type); int ant = __alignof__(native_type); if (st != snt || at != ant)