1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
|
// { dg-options "-std=gnu++11" }
// Copyright (C) 2009-2015 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// { dg-options "-std=gnu++11 -DITERATIONS=5" { target simulator } }
// 25.3.6 Heap operations [lib.alg.heap.operations]
#undef _GLIBCXX_CONCEPT_CHECKS
#include <algorithm>
#include <testsuite_hooks.h>
#include <testsuite_iterators.h>
#include <testsuite_rvalref.h>
#ifndef ITERATIONS
#define ITERATIONS 9
#endif
using __gnu_test::test_container;
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 are_ordered(const rvalstruct& lhs, const rvalstruct& rhs)
{ return lhs < rhs; }
bool are_ordered_int(const int& lhs, const int& rhs)
{ return lhs < rhs; }
void
check_make(int* array, int length)
{
bool test __attribute__((unused)) = true;
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(), are_ordered);
std::make_heap(makecon_ref.begin(), makecon_ref.end(), are_ordered_int);
for (int z = 0; z < length; ++z)
VERIFY( makeheap[z] == makeheap_ref[z] );
VERIFY( std::__is_heap(makecon.begin(), makecon.end(), are_ordered) );
for (int z = 0; z < length; ++z)
VERIFY( makeheap[z].valid );
}
void
check_pop(int* array, int length)
{
bool test __attribute__((unused)) = true;
rvalstruct popheap[9];
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(), are_ordered);
std::pop_heap(popcon_ref.begin(), popcon_ref.end(), are_ordered_int);
for (int z = 0; z < length; ++z)
VERIFY( popheap[z] == popheap_ref[z] );
VERIFY( (std::__is_heap(popheap, popheap + length - 1), are_ordered) );
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)
{
bool test __attribute__((unused)) = true;
rvalstruct sortheap[9];
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(), are_ordered);
std::sort_heap(sortcon_ref.begin(), sortcon_ref.end(), are_ordered_int);
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)
{
bool test __attribute__((unused)) = true;
rvalstruct pushheap[10];
int pushheap_ref[10];
std::copy(array, array + length, pushheap);
std::copy(array, array + length, pushheap_ref);
pushheap[length] = pushval;
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(), are_ordered);
std::push_heap(pushcon_ref.begin(), pushcon_ref.end(), are_ordered_int);
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 < ITERATIONS; ++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, are_ordered_int))
{
check_pop(array, i);
check_sort(array, i);
for (int pushval = -1; pushval <= i; ++pushval)
check_push(array, pushval, i);
}
}
}
}
int
main()
{
test01();
return 0;
}
|