1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // <algorithm> 11 12 // template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred> 13 // requires OutputIterator<Iter, RvalueOf<Iter::reference>::type> 14 // && CopyConstructible<Pred> 15 // Iter 16 // unique(Iter first, Iter last, Pred pred); 17 18 #include <algorithm> 19 #include <cassert> 20 #include <memory> 21 22 #include "test_macros.h" 23 #include "test_iterators.h" 24 25 struct count_equal 26 { 27 static unsigned count; 28 template <class T> 29 bool operator()(const T& x, const T& y) 30 {++count; return x == y;} 31 }; 32 33 unsigned count_equal::count = 0; 34 35 template <class Iter> 36 void 37 test() 38 { 39 int ia[] = {0}; 40 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 41 count_equal::count = 0; 42 Iter r = std::unique(Iter(ia), Iter(ia+sa), count_equal()); 43 assert(base(r) == ia + sa); 44 assert(ia[0] == 0); 45 assert(count_equal::count == sa-1); 46 47 int ib[] = {0, 1}; 48 const unsigned sb = sizeof(ib)/sizeof(ib[0]); 49 count_equal::count = 0; 50 r = std::unique(Iter(ib), Iter(ib+sb), count_equal()); 51 assert(base(r) == ib + sb); 52 assert(ib[0] == 0); 53 assert(ib[1] == 1); 54 assert(count_equal::count == sb-1); 55 56 int ic[] = {0, 0}; 57 const unsigned sc = sizeof(ic)/sizeof(ic[0]); 58 count_equal::count = 0; 59 r = std::unique(Iter(ic), Iter(ic+sc), count_equal()); 60 assert(base(r) == ic + 1); 61 assert(ic[0] == 0); 62 assert(count_equal::count == sc-1); 63 64 int id[] = {0, 0, 1}; 65 const unsigned sd = sizeof(id)/sizeof(id[0]); 66 count_equal::count = 0; 67 r = std::unique(Iter(id), Iter(id+sd), count_equal()); 68 assert(base(r) == id + 2); 69 assert(id[0] == 0); 70 assert(id[1] == 1); 71 assert(count_equal::count == sd-1); 72 73 int ie[] = {0, 0, 1, 0}; 74 const unsigned se = sizeof(ie)/sizeof(ie[0]); 75 count_equal::count = 0; 76 r = std::unique(Iter(ie), Iter(ie+se), count_equal()); 77 assert(base(r) == ie + 3); 78 assert(ie[0] == 0); 79 assert(ie[1] == 1); 80 assert(ie[2] == 0); 81 assert(count_equal::count == se-1); 82 83 int ig[] = {0, 0, 1, 1}; 84 const unsigned sg = sizeof(ig)/sizeof(ig[0]); 85 count_equal::count = 0; 86 r = std::unique(Iter(ig), Iter(ig+sg), count_equal()); 87 assert(base(r) == ig + 2); 88 assert(ig[0] == 0); 89 assert(ig[1] == 1); 90 assert(count_equal::count == sg-1); 91 92 int ih[] = {0, 1, 1}; 93 const unsigned sh = sizeof(ih)/sizeof(ih[0]); 94 count_equal::count = 0; 95 r = std::unique(Iter(ih), Iter(ih+sh), count_equal()); 96 assert(base(r) == ih + 2); 97 assert(ih[0] == 0); 98 assert(ih[1] == 1); 99 assert(count_equal::count == sh-1); 100 101 int ii[] = {0, 1, 1, 1, 2, 2, 2}; 102 const unsigned si = sizeof(ii)/sizeof(ii[0]); 103 count_equal::count = 0; 104 r = std::unique(Iter(ii), Iter(ii+si), count_equal()); 105 assert(base(r) == ii + 3); 106 assert(ii[0] == 0); 107 assert(ii[1] == 1); 108 assert(ii[2] == 2); 109 assert(count_equal::count == si-1); 110 } 111 112 #if TEST_STD_VER >= 11 113 114 struct do_nothing 115 { 116 void operator()(void*) const {} 117 }; 118 119 typedef std::unique_ptr<int, do_nothing> Ptr; 120 121 template <class Iter> 122 void 123 test1() 124 { 125 int one = 1; 126 int two = 2; 127 Ptr ia[1]; 128 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 129 count_equal::count = 0; 130 Iter r = std::unique(Iter(ia), Iter(ia+sa), count_equal()); 131 assert(base(r) == ia + sa); 132 assert(ia[0] == 0); 133 assert(count_equal::count == sa-1); 134 135 Ptr ib[2]; 136 ib[1].reset(&one); 137 const unsigned sb = sizeof(ib)/sizeof(ib[0]); 138 count_equal::count = 0; 139 r = std::unique(Iter(ib), Iter(ib+sb), count_equal()); 140 assert(base(r) == ib + sb); 141 assert(ib[0] == 0); 142 assert(*ib[1] == 1); 143 assert(count_equal::count == sb-1); 144 145 Ptr ic[2]; 146 const unsigned sc = sizeof(ic)/sizeof(ic[0]); 147 count_equal::count = 0; 148 r = std::unique(Iter(ic), Iter(ic+sc), count_equal()); 149 assert(base(r) == ic + 1); 150 assert(ic[0] == 0); 151 assert(count_equal::count == sc-1); 152 153 Ptr id[3]; 154 id[2].reset(&one); 155 const unsigned sd = sizeof(id)/sizeof(id[0]); 156 count_equal::count = 0; 157 r = std::unique(Iter(id), Iter(id+sd), count_equal()); 158 assert(base(r) == id + 2); 159 assert(id[0] == 0); 160 assert(*id[1] == 1); 161 assert(count_equal::count == sd-1); 162 163 Ptr ie[4]; 164 ie[2].reset(&one); 165 const unsigned se = sizeof(ie)/sizeof(ie[0]); 166 count_equal::count = 0; 167 r = std::unique(Iter(ie), Iter(ie+se), count_equal()); 168 assert(base(r) == ie + 3); 169 assert(ie[0] == 0); 170 assert(*ie[1] == 1); 171 assert(ie[2] == 0); 172 assert(count_equal::count == se-1); 173 174 Ptr ig[4]; 175 ig[2].reset(&one); 176 ig[3].reset(&one); 177 const unsigned sg = sizeof(ig)/sizeof(ig[0]); 178 count_equal::count = 0; 179 r = std::unique(Iter(ig), Iter(ig+sg), count_equal()); 180 assert(base(r) == ig + 2); 181 assert(ig[0] == 0); 182 assert(*ig[1] == 1); 183 assert(count_equal::count == sg-1); 184 185 Ptr ih[3]; 186 ih[1].reset(&one); 187 ih[2].reset(&one); 188 const unsigned sh = sizeof(ih)/sizeof(ih[0]); 189 count_equal::count = 0; 190 r = std::unique(Iter(ih), Iter(ih+sh), count_equal()); 191 assert(base(r) == ih + 2); 192 assert(ih[0] == 0); 193 assert(*ih[1] == 1); 194 assert(count_equal::count == sh-1); 195 196 Ptr ii[7]; 197 ii[1].reset(&one); 198 ii[2].reset(&one); 199 ii[3].reset(&one); 200 ii[4].reset(&two); 201 ii[5].reset(&two); 202 ii[6].reset(&two); 203 const unsigned si = sizeof(ii)/sizeof(ii[0]); 204 count_equal::count = 0; 205 r = std::unique(Iter(ii), Iter(ii+si), count_equal()); 206 assert(base(r) == ii + 3); 207 assert(ii[0] == 0); 208 assert(*ii[1] == 1); 209 assert(*ii[2] == 2); 210 assert(count_equal::count == si-1); 211 } 212 #endif // TEST_STD_VER >= 11 213 214 int main() 215 { 216 test<forward_iterator<int*> >(); 217 test<bidirectional_iterator<int*> >(); 218 test<random_access_iterator<int*> >(); 219 test<int*>(); 220 221 #if TEST_STD_VER >= 11 222 test1<forward_iterator<Ptr*> >(); 223 test1<bidirectional_iterator<Ptr*> >(); 224 test1<random_access_iterator<Ptr*> >(); 225 test1<Ptr*>(); 226 #endif 227 } 228