moveable.cc: Fix and extend.

2007-10-11  Paolo Carlini  <pcarlini@suse.de>

	* testsuite/25_algorithms/heap/moveable.cc: Fix and extend.

From-SVN: r129231

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index cce3db17a065628dfed430eee1baaac02701fd75..32449299b3e72ae2ccddfff97c57aaca6a8177f0 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,7 @@
+2007-10-11  Paolo Carlini  <pcarlini@suse.de>
+
+       * testsuite/25_algorithms/heap/moveable.cc: Fix and extend.
+
 2007-10-11  Danny Smith  <dannysmith@users.sourceforge.net>
 
        PR libstdc++/33578

diff --git a/libstdc++-v3/testsuite/25_algorithms/heap/moveable.cc b/libstdc++-v3/testsuite/25_algorithms/heap/moveable.cc
index 2477902b55b96ccd45723dcbf67cd64d23680f60..fe18dbf1e4d5ee37851d0f8ff7dd415bccedbdb7 100644 (file)
--- a/libstdc++-v3/testsuite/25_algorithms/heap/moveable.cc
+++ b/libstdc++-v3/testsuite/25_algorithms/heap/moveable.cc
@@ -34,82 +34,104 @@ using __gnu_test::random_access_iterator_wrapper;
 using __gnu_test::rvalstruct;
 
 typedef test_container<rvalstruct, random_access_iterator_wrapper> container;
+typedef test_container<int, random_access_iterator_wrapper> container_ref;
 
 bool test __attribute__((unused)) = true;
 
-
 void 
 check_make(int* array, int length)
 {
   rvalstruct makeheap[9];
+  int        makeheap_ref[9];
   std::copy(array, array + length, makeheap);
+  std::copy(array, array + length, makeheap_ref);  
   container makecon(makeheap, makeheap + length);
+  container_ref makecon_ref(makeheap_ref, makeheap_ref + length);
   std::make_heap(makecon.begin(), makecon.end());
-  VERIFY(std::__is_heap(makecon.begin(), makecon.end()));
-  for(int z = 0; z < length; ++z)
-    VERIFY(makeheap[z].valid);
+  std::make_heap(makecon_ref.begin(), makecon_ref.end());
+  for (int z = 0; z < length; ++z)
+    VERIFY( makeheap[z] == makeheap_ref[z] );
+  VERIFY( std::__is_heap(makecon.begin(), makecon.end()) );
+  for (int z = 0; z < length; ++z)
+    VERIFY( makeheap[z].valid );
 }
 
 void
 check_pop(int* array, int length)
 {
   rvalstruct popheap[9];
-  std::copy(array, array + length, popheap);   
+  int        popheap_ref[9];
+  std::copy(array, array + length, popheap);
+  std::copy(array, array + length, popheap_ref);
   container popcon(popheap, popheap + length);
+  container_ref popcon_ref(popheap_ref, popheap_ref + length);
   std::pop_heap(popcon.begin(), popcon.end());
-  VERIFY(std::__is_heap(popheap, popheap + length - 1));
-  for(int z = 0; z < length; ++z)
-    VERIFY(popheap[z].val <= popheap[length-1].val && popheap[z].valid);
+  std::pop_heap(popcon_ref.begin(), popcon_ref.end());
+  for (int z = 0; z < length; ++z)
+    VERIFY( popheap[z] == popheap_ref[z] );
+  VERIFY( (std::__is_heap(popheap, popheap + length - 1)) );
+  for (int z = 0; z < length; ++z)
+    VERIFY( popheap[z].val <= popheap[length-1].val && popheap[z].valid );
 }
 
 void
 check_sort(int* array, int length)
 {
   rvalstruct sortheap[9];
-  std::copy(array, array + length, sortheap);   
+  int        sortheap_ref[9];
+  std::copy(array, array + length, sortheap);
+  std::copy(array, array + length, sortheap_ref);
   container sortcon(sortheap, sortheap + length);
+  container_ref sortcon_ref(sortheap_ref, sortheap_ref + length);
   std::sort_heap(sortcon.begin(), sortcon.end());
-  for(int z = 0; z < length - 1; ++z)
-    VERIFY(sortheap[z].val <= sortheap[z + 1].val && sortheap[z].valid);
-  VERIFY(sortheap[length - 1].valid);
+  std::sort_heap(sortcon_ref.begin(), sortcon_ref.end());
+  for (int z = 0; z < length; ++z)
+    VERIFY( sortheap[z] == sortheap_ref[z] );
+  for (int z = 0; z < length - 1; ++z)
+    VERIFY( sortheap[z].val <= sortheap[z + 1].val && sortheap[z].valid );
+  VERIFY( sortheap[length - 1].valid );
 }
 
 void
 check_push(int* array, int pushval, int length)
 {
   rvalstruct pushheap[10];
+  int        pushheap_ref[10];
   std::copy(array, array + length, pushheap);
+  std::copy(array, array + length, pushheap_ref);  
   pushheap[length] = pushval;
-  container pushcon(pushheap, pushheap + length);
+  pushheap_ref[length] = pushval;
+  container pushcon(pushheap, pushheap + length + 1);
+  container_ref pushcon_ref(pushheap_ref, pushheap_ref + length + 1);
   std::push_heap(pushcon.begin(), pushcon.end());
-  VERIFY(std::__is_heap(pushheap, pushheap + length));
-  for(int z = 0; z < length ; ++z)
-    VERIFY(pushheap[z].valid);
+  std::push_heap(pushcon_ref.begin(), pushcon_ref.end());
+  for (int z = 0; z < length + 1; ++z)
+    VERIFY( pushheap[z] == pushheap_ref[z] );
+  VERIFY( std::__is_heap(pushheap, pushheap + length + 1) );
+  for (int z = 0; z < length + 1; ++z)
+    VERIFY( pushheap[z].valid );
 }
 
-
 void
 test01()
 {
   int array[9];
-  for(int i = 1; i < 9; ++i)
-  {
-    for(int z = 0; z < i; ++z)
-      array[i] = i;
-    while(std::next_permutation(array, array + i))
+  for (int i = 1; i < 9; ++i)
     {
-      check_make(array, i);
-      if(std::__is_heap(array, array + i))
-      {
-        check_pop(array, i);
-        check_sort(array, i);
-        for(int pushval = -1; pushval <= i; ++pushval)
-        {
-          check_push(array, pushval, i);
-        }
-      }
+      for(int z = 0; z < i; ++z)
+       array[z] = z;
+      while (std::next_permutation(array, array + i))
+       {
+         check_make(array, i);
+         if (std::__is_heap(array, array + i))
+           {
+             check_pop(array, i);
+             check_sort(array, i);
+             for (int pushval = -1; pushval <= i; ++pushval)
+               check_push(array, pushval, i);
+           }
+       }
     }
-  }
 }
 
 int