[gcc r12-2701] libstdc++: Remove trailing whitespace in some tests

Jonathan Wakely redi@gcc.gnu.org
Tue Aug 3 15:34:02 GMT 2021


https://gcc.gnu.org/g:9bd87e388724baab9597ef232ea7e855c99eb7d7

commit r12-2701-g9bd87e388724baab9597ef232ea7e855c99eb7d7
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Tue Aug 3 00:05:01 2021 +0100

    libstdc++: Remove trailing whitespace in some tests
    
    Signed-off-by: Jonathan Wakely <jwakely@redhat.com>
    
    libstdc++-v3/ChangeLog:
    
            * testsuite/20_util/function_objects/binders/3113.cc: Remove
            trailing whitespace.
            * testsuite/20_util/shared_ptr/assign/auto_ptr.cc: Likewise.
            * testsuite/20_util/shared_ptr/assign/auto_ptr_neg.cc: Likewise.
            * testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue.cc:
            Likewise.
            * testsuite/20_util/shared_ptr/creation/dr925.cc: Likewise.
            * testsuite/25_algorithms/headers/algorithm/synopsis.cc:
            Likewise.
            * testsuite/25_algorithms/random_shuffle/requirements/explicit_instantiation/2.cc:
            Likewise.
            * testsuite/25_algorithms/random_shuffle/requirements/explicit_instantiation/pod.cc:
            Likewise.

Diff:
---
 .../20_util/function_objects/binders/3113.cc       |  22 +--
 .../20_util/shared_ptr/assign/auto_ptr.cc          |   2 +-
 .../20_util/shared_ptr/assign/auto_ptr_neg.cc      |   2 +-
 .../20_util/shared_ptr/assign/auto_ptr_rvalue.cc   |   2 +-
 .../testsuite/20_util/shared_ptr/creation/dr925.cc |   6 +-
 .../25_algorithms/headers/algorithm/synopsis.cc    | 212 ++++++++++-----------
 .../requirements/explicit_instantiation/2.cc       |   4 +-
 .../requirements/explicit_instantiation/pod.cc     |   4 +-
 8 files changed, 127 insertions(+), 127 deletions(-)

diff --git a/libstdc++-v3/testsuite/20_util/function_objects/binders/3113.cc b/libstdc++-v3/testsuite/20_util/function_objects/binders/3113.cc
index 0b671ae4a0e..03118b291b1 100644
--- a/libstdc++-v3/testsuite/20_util/function_objects/binders/3113.cc
+++ b/libstdc++-v3/testsuite/20_util/function_objects/binders/3113.cc
@@ -25,22 +25,22 @@
 #include <algorithm> // for_each
 #include <functional>
 
-class Elem 
-{ 
-public: 
-  void print(int) const { } 
-  void modify(int) { } 
-}; 
+class Elem
+{
+public:
+  void print(int) const { }
+  void modify(int) { }
+};
 
 // libstdc++/3113
 void test01()
-{ 
-  std::vector<Elem> coll(2); 
-  // OK 
-  std::for_each(coll.begin(), coll.end(), 
+{
+  std::vector<Elem> coll(2);
+  // OK
+  std::for_each(coll.begin(), coll.end(),
 	   std::bind2nd(std::mem_fun_ref(&Elem::print), 42));
   // OK
-  std::for_each(coll.begin(), coll.end(), 
+  std::for_each(coll.begin(), coll.end(),
 	   std::bind2nd(std::mem_fun_ref(&Elem::modify), 42));
 }
 
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr.cc
index 82750dca9a9..39574984c7d 100644
--- a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr.cc
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr.cc
@@ -78,7 +78,7 @@ test01()
   return 0;
 }
 
-int 
+int
 main()
 {
   test01();
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_neg.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_neg.cc
index 32af6001366..9d0393be22a 100644
--- a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_neg.cc
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_neg.cc
@@ -40,7 +40,7 @@ test01()
   return 0;
 }
 
-int 
+int
 main()
 {
   test01();
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue.cc
index 2f6e4db18d9..503fb348aa2 100644
--- a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue.cc
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue.cc
@@ -44,7 +44,7 @@ test02()
   a = std::move(au);
 }
 
-int 
+int
 main()
 {
   test01();
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/creation/dr925.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/dr925.cc
index 87e89375d28..25ff611f8d6 100644
--- a/libstdc++-v3/testsuite/20_util/shared_ptr/creation/dr925.cc
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/dr925.cc
@@ -28,19 +28,19 @@ struct A
 {
 };
 
-std::unique_ptr<A> 
+std::unique_ptr<A>
 create_unique_ptr()
 {
   return std::unique_ptr<A>(new A());
 }
 
-std::auto_ptr<A> 
+std::auto_ptr<A>
 create_auto_ptr()
 {
   return std::auto_ptr<A>(new A());
 }
 
-void 
+void
 process(std::shared_ptr<A> a)
 {
   VERIFY( a.get() != 0 );
diff --git a/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc
index dbf58fb64a6..68f5d425b4d 100644
--- a/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc
+++ b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc
@@ -24,12 +24,12 @@ namespace std
   // 25.1, non-modifying sequence operations:
   template<typename _IIter, typename _Funct>
     _GLIBCXX20_CONSTEXPR
-    _Funct 
+    _Funct
     for_each(_IIter, _IIter, _Funct);
 
   template<typename _IIter, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    _IIter 
+    _IIter
     find(_IIter, _IIter, const _Tp&);
 
   template<typename _IIter, typename _Predicate>
@@ -91,12 +91,12 @@ namespace std
 
   template<typename _FIter>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     adjacent_find(_FIter, _FIter);
 
   template<typename _FIter, typename _BinaryPredicate>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     adjacent_find(_FIter, _FIter, _BinaryPredicate);
 
   template<typename _IIter, typename _Tp>
@@ -121,40 +121,40 @@ namespace std
 
   template<typename _IIter1, typename _IIter2>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     equal(_IIter1, _IIter1, _IIter2);
 
   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 
   template<typename _FIter1, typename _FIter2>
     _GLIBCXX20_CONSTEXPR
-    _FIter1 
+    _FIter1
     search(_FIter1, _FIter1, _FIter2, _FIter2);
 
   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
     _GLIBCXX20_CONSTEXPR
-    _FIter1 
+    _FIter1
     search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 
   template<typename _FIter, typename _Size, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     search_n(_FIter, _FIter, _Size, const _Tp&);
 
-  template<typename _FIter, typename _Size, typename _Tp, 
+  template<typename _FIter, typename _Size, typename _Tp,
 	   typename _BinaryPredicate>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
 
   // 25.2, modifying sequence operations:
   // 25.2.1, copy:
   template<typename _IIter, typename _OIter>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     copy(_IIter, _IIter, _OIter);
 
   template<typename _BIter1, typename _BIter2>
@@ -164,9 +164,9 @@ namespace std
 
   // 25.2.2, swap:
 #if __cplusplus < 201103L
-  template<typename _Tp> 
+  template<typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     swap(_Tp&, _Tp& b);
 
   template<typename _Tp, size_t _Nm>
@@ -181,89 +181,89 @@ namespace std
 
   template<typename _FIter1, typename _FIter2>
     _GLIBCXX20_CONSTEXPR
-    _FIter2 
+    _FIter2
     swap_ranges(_FIter1 first1, _FIter1, _FIter2);
 
   template<typename _FIter1, typename _FIter2>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     iter_swap(_FIter1, _FIter2 b);
 
   template<typename _IIter, typename _OIter, typename _UnaryOperation>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     transform(_IIter, _IIter, _OIter, _UnaryOperation op);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, 
+  template<typename _IIter1, typename _IIter2, typename _OIter,
 	   typename _BinaryOperation>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
 
   template<typename _FIter, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     replace(_FIter, _FIter, const _Tp&, const _Tp&);
 
   template<typename _FIter, typename _Predicate, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     replace_if(_FIter, _FIter, _Predicate, const _Tp&);
 
   template<typename _IIter, typename _OIter, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
 
   template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
 
   template<typename _FIter, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     fill(_FIter, _FIter, const _Tp&);
 
   template<typename _OIter, typename _Size, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     fill_n(_OIter, _Size n, const _Tp&);
 
   template<typename _FIter, typename _Generator>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     generate(_FIter, _FIter, _Generator);
 
   template<typename _OIter, typename _Size, typename _Generator>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     generate_n(_OIter, _Size, _Generator);
 
   template<typename _FIter, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     remove(_FIter, _FIter, const _Tp&);
 
   template<typename _FIter, typename _Predicate>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     remove_if(_FIter, _FIter, _Predicate);
 
   template<typename _IIter, typename _OIter, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     remove_copy(_IIter, _IIter, _OIter, const _Tp&);
 
   template<typename _IIter, typename _OIter, typename _Predicate>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
 
 #if __cplusplus >= 201103L
   template<typename _IIter, typename _OIter, typename _Predicate>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     copy_if(_IIter, _IIter, _OIter, _Predicate);
 
   template<typename _IIter, typename _Size, typename _OIter>
@@ -280,51 +280,51 @@ namespace std
 
   template<typename _FIter>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     unique(_FIter, _FIter);
 
   template<typename _FIter, typename _BinaryPredicate>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     unique(_FIter, _FIter, _BinaryPredicate);
 
   template<typename _IIter, typename _OIter>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     unique_copy(_IIter, _IIter, _OIter);
 
   template<typename _IIter, typename _OIter, typename _BinaryPredicate>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
 
   template<typename _BIter>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     reverse(_BIter, _BIter);
 
   template<typename _BIter, typename _OIter>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     reverse_copy(_BIter, _BIter, _OIter);
 
   template<typename _FIter>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     rotate(_FIter, _FIter, _FIter);
 
   template<typename _FIter, typename _OIter>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     rotate_copy (_FIter, _FIter, _FIter, _OIter);
 
 #if __cplusplus <= 201103L
   template<typename _RAIter>
-    void 
+    void
     random_shuffle(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Generator>
-    void 
+    void
     random_shuffle(_RAIter, _RAIter, _Generator&);
 #endif
 
@@ -337,41 +337,41 @@ namespace std
   // 25.2.12, partitions:
   template<typename _BIter, typename _Predicate>
     _GLIBCXX20_CONSTEXPR
-    _BIter 
+    _BIter
     partition(_BIter, _BIter, _Predicate);
 
   template<typename _BIter, typename _Predicate>
-    _BIter 
+    _BIter
     stable_partition(_BIter, _BIter, _Predicate);
 
   // 25.3, sorting and related operations:
   // 25.3.1, sorting:
   template<typename _RAIter>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     sort(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     sort(_RAIter, _RAIter, _Compare);
 
   template<typename _RAIter>
-    void 
+    void
     stable_sort(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
-    void 
+    void
     stable_sort(_RAIter, _RAIter, _Compare);
 
   template<typename _RAIter>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     partial_sort(_RAIter, _RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
 
   template<typename _IIter, typename _RAIter>
@@ -386,33 +386,33 @@ namespace std
 
   template<typename _RAIter>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     nth_element(_RAIter, _RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     nth_element(_RAIter, _RAIter, _RAIter, _Compare);
 
   // 25.3.3, binary search:
   template<typename _FIter, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     lower_bound(_FIter, _FIter, const _Tp&);
 
   template<typename _FIter, typename _Tp, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     lower_bound(_FIter, _FIter, const _Tp&, _Compare);
 
   template<typename _FIter, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     upper_bound(_FIter, _FIter, const _Tp&);
 
   template<typename _FIter, typename _Tp, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     upper_bound(_FIter, _FIter, const _Tp&, _Compare);
 
   template<typename _FIter, typename _Tp>
@@ -427,76 +427,76 @@ namespace std
 
   template<typename _FIter, typename _Tp>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     binary_search(_FIter, _FIter, const _Tp&);
 
   template<typename _FIter, typename _Tp, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     binary_search(_FIter, _FIter, const _Tp&, _Compare);
 
   // 25.3.4, merge:
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, 
+  template<typename _IIter1, typename _IIter2, typename _OIter,
 	   typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 
   template<typename _BIter>
-    void 
+    void
     inplace_merge(_BIter, _BIter, _BIter);
 
   template<typename _BIter, typename _Compare>
-    void 
+    void
     inplace_merge(_BIter, _BIter, _BIter, _Compare);
 
   // 25.3.5, set operations:
   template<typename _IIter1, typename _IIter2>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     includes(_IIter1, _IIter1, _IIter2, _IIter2);
 
   template<typename _IIter1, typename _IIter2, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
 	   typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
 	   typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, 
+  template<typename _IIter1, typename _IIter2, typename _OIter,
 	   typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    _OIter 
+    _OIter
     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
@@ -504,135 +504,135 @@ namespace std
     _OIter
     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, 
+  template<typename _IIter1, typename _IIter2, typename _OIter,
 	   typename _Compare>
     _GLIBCXX20_CONSTEXPR
     _OIter
-    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, 
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
 			     _OIter, _Compare);
 
   // 25.3.6, heap operations:
   template<typename _RAIter>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     push_heap(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     push_heap(_RAIter, _RAIter, _Compare);
 
   template<typename _RAIter>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     pop_heap(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     pop_heap(_RAIter, _RAIter, _Compare);
 
   template<typename _RAIter>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     make_heap(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     make_heap(_RAIter, _RAIter, _Compare);
 
   template<typename _RAIter>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     sort_heap(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    void 
+    void
     sort_heap(_RAIter, _RAIter, _Compare);
 
 #if __cplusplus >= 201103L
   template<typename _RAIter>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     is_heap(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     is_heap(_RAIter, _RAIter, _Compare);
 
   template<typename _RAIter>
     _GLIBCXX20_CONSTEXPR
-    _RAIter 
+    _RAIter
     is_heap_until(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    _RAIter 
+    _RAIter
     is_heap_until(_RAIter, _RAIter, _Compare);
 
   template<typename _FIter>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     is_sorted(_FIter, _FIter);
 
   template<typename _FIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     is_sorted(_FIter, _FIter, _Compare);
 
   template<typename _FIter>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     is_sorted_until(_FIter, _FIter);
 
   template<typename _FIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    _FIter 
+    _FIter
     is_sorted_until(_FIter, _FIter, _Compare);
 #endif
 
   // 25.3.7, minimum and maximum:
-  template<typename _Tp> 
+  template<typename _Tp>
     _GLIBCXX14_CONSTEXPR
-    const _Tp& 
+    const _Tp&
     min(const _Tp&, const _Tp&);
 
   template<typename _Tp, typename _Compare>
     _GLIBCXX14_CONSTEXPR
-    const _Tp& 
+    const _Tp&
     min(const _Tp&, const _Tp&, _Compare);
 
-  template<typename _Tp> 
+  template<typename _Tp>
     _GLIBCXX14_CONSTEXPR
-    const _Tp& 
+    const _Tp&
     max(const _Tp&, const _Tp&);
 
   template<typename _Tp, typename _Compare>
     _GLIBCXX14_CONSTEXPR
-    const _Tp& 
+    const _Tp&
     max(const _Tp&, const _Tp&, _Compare);
 
   template<typename _FIter>
     _GLIBCXX14_CONSTEXPR
-    _FIter 
+    _FIter
     min_element(_FIter, _FIter);
 
   template<typename _FIter, typename _Compare>
     _GLIBCXX14_CONSTEXPR
-    _FIter 
+    _FIter
     min_element(_FIter, _FIter, _Compare);
 
   template<typename _FIter>
     _GLIBCXX14_CONSTEXPR
-    _FIter 
+    _FIter
     max_element(_FIter, _FIter);
 
   template<typename _FIter, typename _Compare>
     _GLIBCXX14_CONSTEXPR
-    _FIter 
+    _FIter
     max_element(_FIter, _FIter, _Compare);
 
 #if __cplusplus >= 201103L
@@ -689,32 +689,32 @@ namespace std
 
   template<typename _IIter1, typename _IIter2>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
 
   template<typename _IIter1, typename _IIter2, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 
   // 25.3.9, permutations
   template<typename _BIter>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     next_permutation(_BIter, _BIter);
 
   template<typename _BIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     next_permutation(_BIter, _BIter, _Compare);
 
   template<typename _BIter>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     prev_permutation(_BIter, _BIter);
 
   template<typename _BIter, typename _Compare>
     _GLIBCXX20_CONSTEXPR
-    bool 
+    bool
     prev_permutation(_BIter, _BIter, _Compare);
 }
diff --git a/libstdc++-v3/testsuite/25_algorithms/random_shuffle/requirements/explicit_instantiation/2.cc b/libstdc++-v3/testsuite/25_algorithms/random_shuffle/requirements/explicit_instantiation/2.cc
index 206c237cbc6..7a12bef063e 100644
--- a/libstdc++-v3/testsuite/25_algorithms/random_shuffle/requirements/explicit_instantiation/2.cc
+++ b/libstdc++-v3/testsuite/25_algorithms/random_shuffle/requirements/explicit_instantiation/2.cc
@@ -34,6 +34,6 @@ namespace std
   typedef std::pointer_to_unary_function<int, int>  generator_type;
 
   template void random_shuffle(iterator_type, iterator_type);
-  template void random_shuffle(iterator_type, iterator_type, 
+  template void random_shuffle(iterator_type, iterator_type,
 			       generator_type&);
-} 
+}
diff --git a/libstdc++-v3/testsuite/25_algorithms/random_shuffle/requirements/explicit_instantiation/pod.cc b/libstdc++-v3/testsuite/25_algorithms/random_shuffle/requirements/explicit_instantiation/pod.cc
index 5e69aa60420..774c39a6aa6 100644
--- a/libstdc++-v3/testsuite/25_algorithms/random_shuffle/requirements/explicit_instantiation/pod.cc
+++ b/libstdc++-v3/testsuite/25_algorithms/random_shuffle/requirements/explicit_instantiation/pod.cc
@@ -33,6 +33,6 @@ namespace std
   typedef std::pointer_to_unary_function<int, int>  generator_type;
 
   template void random_shuffle(iterator_type, iterator_type);
-  template void random_shuffle(iterator_type, iterator_type, 
+  template void random_shuffle(iterator_type, iterator_type,
 			       generator_type&);
-} 
+}


More information about the Libstdc++-cvs mailing list