1 /////////////////////////////////////////////////////////////////////////////
2 // Copyright (c) Electronic Arts Inc. All rights reserved.
3 /////////////////////////////////////////////////////////////////////////////
4
5
6 #if defined(_MSC_VER)
7 // We have little choice but to disable this warning. See the FAQ for why.
8 #pragma warning(disable: 4244) // conversion from '___' to '___', possible loss of data
9 #endif
10
11
12 #include <EASTL/algorithm.h>
13 #include <EASTL/functional.h>
14 #include <EASTL/unique_ptr.h>
15 #include <EASTL/vector.h>
16 #include <EASTL/array.h>
17 #include <EASTL/deque.h>
18 #include <EASTL/list.h>
19 #include <EASTL/slist.h>
20 #include <EASTL/string.h>
21 #include <EASTL/set.h>
22 #include <EASTL/sort.h>
23 #include "ConceptImpls.h"
24 #include <EAStdC/EAMemory.h>
25 #include "EASTLTest.h" // Put this after the above so that it doesn't block any warnings from the includes above.
26
27 namespace eastl
28 {
29 #if 0
30 // These are some tests of altermative implementations of branch-free min/max functions.
31 /*
32 union FloatInt32Union
33 {
34 float f;
35 int32_t i;
36 };
37
38 inline float min_alt2(float a, float b)
39 {
40 FloatInt32Union uc;
41 uc.f = a - b;
42
43 const float choices[2] = { a, b };
44 return (choices + 1)[uc.i >> 31];
45 }
46
47 inline float min_alt3(float a, float b)
48 {
49 FloatInt32Union uc, ua, ub, ur;
50
51 uc.f = a - b;
52 uc.i >>= 31;
53 ua.f = a;
54 ub.f = b;
55 ur.i = (ua.i & uc.i) | (ub.i & ~uc.i);
56
57 return ur.f;
58 }
59 */
60 #endif
61 }
62
63
64 namespace
65 {
66 struct A{
A__anon2e2f97860111::A67 A(int n) : a(n){}
68 int a;
69 };
operator ()__anon2e2f97860111::LessStruct70 struct LessStruct{ bool operator()(const A& a1, const A& a2){ return a1.a < a2.a; } };
71
72
73 struct B{
B__anon2e2f97860111::B74 B(int n) : b(n){}
75 int b;
76 };
LessFunction(const B & b1,const B & b2)77 inline bool LessFunction(const B& b1, const B& b2){ return b1.b < b2.b; }
78 }
79
80 enum TestMinMaxEnum
81 {
82 teX = 0,
83 teY = 3
84 };
85
86
87 ///////////////////////////////////////////////////////////////////////////////
88 // Greater
89 //
90 // A version of greater that uses operator < instead of operator >.
91 //
92 template <typename T>
93 struct Greater : public eastl::binary_function<T, T, bool>
94 {
operator ()Greater95 bool operator()(const T& a, const T& b) const
96 { return (b < a); }
97 };
98
99
100 ///////////////////////////////////////////////////////////////////////////////
101 // DivisibleBy
102 //
103 struct DivisibleBy
104 {
105 int d;
DivisibleByDivisibleBy106 DivisibleBy(int n = 1) : d(n) {}
operator ()DivisibleBy107 bool operator()(int n) const { return ((n % d) == 0); }
108 };
109
110
111 ///////////////////////////////////////////////////////////////////////////////
112 // TestObjectNegate
113 //
114 struct TestObjectNegate : public eastl::unary_function<TestObject, TestObject>
115 {
operator ()TestObjectNegate116 TestObject operator()(const TestObject& a) const
117 { return TestObject(-a.mX); }
118 };
119
TestMinMax()120 static int TestMinMax()
121 {
122 using namespace eastl;
123
124 int nErrorCount = 0;
125
126 EA::UnitTest::Rand rng(EA::UnitTest::GetRandSeed());
127
128 {
129 // NOTE(rparolin): This compiles but it should not. We provide explicit eastl::max overloads for float, double,
130 // and long double which enable this behaviour. It is not standards compliant and it will be removed in a
131 // future release.
132 {
133 struct Foo
134 {
135 operator float() const { return 0; }
136 };
137
138 Foo f1;
139 float f2{};
140 eastl::max(f1, f2);
141 }
142
143 // NOTE(rparolin): This will not compile because we lack explicit eastl::max overloads for 'int'.
144 // {
145 // struct Foo
146 // {
147 // operator int() const { return 0; }
148 // };
149
150 // Foo f1;
151 // int f2{};
152 // eastl::max(f1, f2);
153 // }
154 }
155
156 {
157 // const T& min(const T& a, const T& b);
158 // const T& min(const T& a, const T& b, Compare compare)
159 // const T& max(const T& a, const T& b);
160 // const T& max(const T& a, const T& b, Compare compare)
161
162 A a1(1), a2(2), a3(3);
163 a3 = min(a1, a2, LessStruct());
164 EATEST_VERIFY(a3.a == 1);
165 a3 = max(a1, a2, LessStruct());
166 EATEST_VERIFY(a3.a == 2);
167
168 B b1(1), b2(2), b3(3);
169 b3 = min(b2, b1, LessFunction);
170 EATEST_VERIFY(b3.b == 1);
171 b3 = max(b2, b1, LessFunction);
172 EATEST_VERIFY(b3.b == 2);
173
174
175 TestObject t1(1), t2(2), t3(3);
176 t3 = min(t2, t1);
177 EATEST_VERIFY(t3.mX == 1);
178 t3 = max(t2, t1);
179 EATEST_VERIFY(t3.mX == 2);
180
181
182 int i1, i2(-1), i3(1);
183 i1 = min(i2, i3);
184 EATEST_VERIFY(i1 == -1);
185 i1 = min(i3, i2);
186 EATEST_VERIFY(i1 == -1);
187 i1 = max(i2, i3);
188 EATEST_VERIFY(i1 == 1);
189 i1 = max(i3, i2);
190 EATEST_VERIFY(i1 == 1);
191
192 const volatile int i2cv(-1), i3cv(1);
193 i1 = min(i2cv, i3cv);
194 EATEST_VERIFY(i1 == -1);
195 i1 = min(i3cv, i2cv);
196 EATEST_VERIFY(i1 == -1);
197 i1 = max(i2cv, i3cv);
198 EATEST_VERIFY(i1 == 1);
199 i1 = max(i3cv, i2cv);
200 EATEST_VERIFY(i1 == 1);
201
202 float f1, f2(-1), f3(1);
203 f1 = min(f2, f3);
204 EATEST_VERIFY(f1 == -1);
205 f1 = min(f3, f2);
206 EATEST_VERIFY(f1 == -1);
207 f1 = max(f2, f3);
208 EATEST_VERIFY(f1 == 1);
209 f1 = max(f3, f2);
210 EATEST_VERIFY(f1 == 1);
211
212 double d1, d2(-1), d3(1);
213 d1 = min(d2, d3);
214 EATEST_VERIFY(d1 == -1);
215 d1 = min(d3, d2);
216 EATEST_VERIFY(d1 == -1);
217 d1 = max(d2, d3);
218 EATEST_VERIFY(d1 == 1);
219 d1 = max(d3, d2);
220 EATEST_VERIFY(d1 == 1);
221
222 void* p1, *p2 = &d2, *p3 = &d3;
223 p1 = min(p2, p3);
224 EATEST_VERIFY((uintptr_t)p1 == min((uintptr_t)p2, (uintptr_t)p3));
225
226 double* pd1, *pd2 = &d2, *pd3 = &d3;
227 pd1 = min(pd2, pd3);
228 EATEST_VERIFY((uintptr_t)pd1 == min((uintptr_t)pd2, (uintptr_t)pd3));
229
230
231 // initializer_list tests
232 #if !defined(EA_COMPILER_NO_INITIALIZER_LISTS)
233 EATEST_VERIFY(min({ 3, 1, 2}) == 1);
234 EATEST_VERIFY(max({ 3, 1, 2}) == 3);
235 #endif
236
237
238 // Test scalar specializations
239 EATEST_VERIFY(min((char)1, (char)1) == 1);
240 EATEST_VERIFY(min((char)1, (char)2) == 1);
241 EATEST_VERIFY(min((char)2, (char)1) == 1);
242
243 EATEST_VERIFY(min((signed char)1, (signed char)1) == 1);
244 EATEST_VERIFY(min((signed char)1, (signed char)2) == 1);
245 EATEST_VERIFY(min((signed char)2, (signed char)1) == 1);
246
247 EATEST_VERIFY(min((unsigned char)1, (unsigned char)1) == 1);
248 EATEST_VERIFY(min((unsigned char)1, (unsigned char)2) == 1);
249 EATEST_VERIFY(min((unsigned char)2, (unsigned char)1) == 1);
250
251 EATEST_VERIFY(min((signed short)1, (signed short)1) == 1);
252 EATEST_VERIFY(min((signed short)1, (signed short)2) == 1);
253 EATEST_VERIFY(min((signed short)2, (signed short)1) == 1);
254
255 EATEST_VERIFY(min((unsigned short)1, (unsigned short)1) == 1);
256 EATEST_VERIFY(min((unsigned short)1, (unsigned short)2) == 1);
257 EATEST_VERIFY(min((unsigned short)2, (unsigned short)1) == 1);
258
259 EATEST_VERIFY(min((signed int)1, (signed int)1) == 1);
260 EATEST_VERIFY(min((signed int)1, (signed int)2) == 1);
261 EATEST_VERIFY(min((signed int)2, (signed int)1) == 1);
262
263 EATEST_VERIFY(min((unsigned int)1, (unsigned int)1) == 1);
264 EATEST_VERIFY(min((unsigned int)1, (unsigned int)2) == 1);
265 EATEST_VERIFY(min((unsigned int)2, (unsigned int)1) == 1);
266
267 EATEST_VERIFY(min((signed long)1, (signed long)1) == 1);
268 EATEST_VERIFY(min((signed long)1, (signed long)2) == 1);
269 EATEST_VERIFY(min((signed long)2, (signed long)1) == 1);
270
271 EATEST_VERIFY(min((unsigned long)1, (unsigned long)1) == 1);
272 EATEST_VERIFY(min((unsigned long)1, (unsigned long)2) == 1);
273 EATEST_VERIFY(min((unsigned long)2, (unsigned long)1) == 1);
274
275 EATEST_VERIFY(min((signed long long)1, (signed long long)1) == 1);
276 EATEST_VERIFY(min((signed long long)1, (signed long long)2) == 1);
277 EATEST_VERIFY(min((signed long long)2, (signed long long)1) == 1);
278
279 EATEST_VERIFY(min((unsigned long long)1, (unsigned long long)1) == 1);
280 EATEST_VERIFY(min((unsigned long long)1, (unsigned long long)2) == 1);
281 EATEST_VERIFY(min((unsigned long long)2, (unsigned long long)1) == 1);
282
283 EATEST_VERIFY(min((float)1, (float)1) == 1);
284 EATEST_VERIFY(min((float)1, (float)2) == 1);
285 EATEST_VERIFY(min((float)2, (float)1) == 1);
286
287 EATEST_VERIFY(min((double)1, (double)1) == 1);
288 EATEST_VERIFY(min((double)1, (double)2) == 1);
289 EATEST_VERIFY(min((double)2, (double)1) == 1);
290
291 EATEST_VERIFY(min((long double)1, (long double)1) == 1);
292 EATEST_VERIFY(min((long double)1, (long double)2) == 1);
293 EATEST_VERIFY(min((long double)2, (long double)1) == 1);
294
295
296 // Test max specializations
297 EATEST_VERIFY(max((char)1, (char)1) == 1);
298 EATEST_VERIFY(max((char)1, (char)2) == 2);
299 EATEST_VERIFY(max((char)2, (char)1) == 2);
300
301 EATEST_VERIFY(max((signed char)1, (signed char)1) == 1);
302 EATEST_VERIFY(max((signed char)1, (signed char)2) == 2);
303 EATEST_VERIFY(max((signed char)2, (signed char)1) == 2);
304
305 EATEST_VERIFY(max((unsigned char)1, (unsigned char)1) == 1);
306 EATEST_VERIFY(max((unsigned char)1, (unsigned char)2) == 2);
307 EATEST_VERIFY(max((unsigned char)2, (unsigned char)1) == 2);
308
309 EATEST_VERIFY(max((signed short)1, (signed short)1) == 1);
310 EATEST_VERIFY(max((signed short)1, (signed short)2) == 2);
311 EATEST_VERIFY(max((signed short)2, (signed short)1) == 2);
312
313 EATEST_VERIFY(max((unsigned short)1, (unsigned short)1) == 1);
314 EATEST_VERIFY(max((unsigned short)1, (unsigned short)2) == 2);
315 EATEST_VERIFY(max((unsigned short)2, (unsigned short)1) == 2);
316
317 EATEST_VERIFY(max((signed int)1, (signed int)1) == 1);
318 EATEST_VERIFY(max((signed int)1, (signed int)2) == 2);
319 EATEST_VERIFY(max((signed int)2, (signed int)1) == 2);
320
321 EATEST_VERIFY(max((unsigned int)1, (unsigned int)1) == 1);
322 EATEST_VERIFY(max((unsigned int)1, (unsigned int)2) == 2);
323 EATEST_VERIFY(max((unsigned int)2, (unsigned int)1) == 2);
324
325 EATEST_VERIFY(max((signed long)1, (signed long)1) == 1);
326 EATEST_VERIFY(max((signed long)1, (signed long)2) == 2);
327 EATEST_VERIFY(max((signed long)2, (signed long)1) == 2);
328
329 EATEST_VERIFY(max((unsigned long)1, (unsigned long)1) == 1);
330 EATEST_VERIFY(max((unsigned long)1, (unsigned long)2) == 2);
331 EATEST_VERIFY(max((unsigned long)2, (unsigned long)1) == 2);
332
333 EATEST_VERIFY(max((signed long long)1, (signed long long)1) == 1);
334 EATEST_VERIFY(max((signed long long)1, (signed long long)2) == 2);
335 EATEST_VERIFY(max((signed long long)2, (signed long long)1) == 2);
336
337 EATEST_VERIFY(max((unsigned long long)1, (unsigned long long)1) == 1);
338 EATEST_VERIFY(max((unsigned long long)1, (unsigned long long)2) == 2);
339 EATEST_VERIFY(max((unsigned long long)2, (unsigned long long)1) == 2);
340
341 EATEST_VERIFY(max((float)1, (float)1) == 1);
342 EATEST_VERIFY(max((float)1, (float)2) == 2);
343 EATEST_VERIFY(max((float)2, (float)1) == 2);
344
345 EATEST_VERIFY(max((double)1, (double)1) == 1);
346 EATEST_VERIFY(max((double)1, (double)2) == 2);
347 EATEST_VERIFY(max((double)2, (double)1) == 2);
348
349 EATEST_VERIFY(max((long double)1, (long double)1) == 1);
350 EATEST_VERIFY(max((long double)1, (long double)2) == 2);
351 EATEST_VERIFY(max((long double)2, (long double)1) == 2);
352
353
354 // Test min_alt specializations
355 EATEST_VERIFY(min_alt((char)1, (char)1) == 1);
356 EATEST_VERIFY(min_alt((char)1, (char)2) == 1);
357 EATEST_VERIFY(min_alt((char)2, (char)1) == 1);
358
359 EATEST_VERIFY(min_alt((signed char)1, (signed char)1) == 1);
360 EATEST_VERIFY(min_alt((signed char)1, (signed char)2) == 1);
361 EATEST_VERIFY(min_alt((signed char)2, (signed char)1) == 1);
362
363 EATEST_VERIFY(min_alt((unsigned char)1, (unsigned char)1) == 1);
364 EATEST_VERIFY(min_alt((unsigned char)1, (unsigned char)2) == 1);
365 EATEST_VERIFY(min_alt((unsigned char)2, (unsigned char)1) == 1);
366
367 EATEST_VERIFY(min_alt((signed short)1, (signed short)1) == 1);
368 EATEST_VERIFY(min_alt((signed short)1, (signed short)2) == 1);
369 EATEST_VERIFY(min_alt((signed short)2, (signed short)1) == 1);
370
371 EATEST_VERIFY(min_alt((unsigned short)1, (unsigned short)1) == 1);
372 EATEST_VERIFY(min_alt((unsigned short)1, (unsigned short)2) == 1);
373 EATEST_VERIFY(min_alt((unsigned short)2, (unsigned short)1) == 1);
374
375 EATEST_VERIFY(min_alt((signed int)1, (signed int)1) == 1);
376 EATEST_VERIFY(min_alt((signed int)1, (signed int)2) == 1);
377 EATEST_VERIFY(min_alt((signed int)2, (signed int)1) == 1);
378
379 EATEST_VERIFY(min_alt((unsigned int)1, (unsigned int)1) == 1);
380 EATEST_VERIFY(min_alt((unsigned int)1, (unsigned int)2) == 1);
381 EATEST_VERIFY(min_alt((unsigned int)2, (unsigned int)1) == 1);
382
383 EATEST_VERIFY(min_alt((signed long)1, (signed long)1) == 1);
384 EATEST_VERIFY(min_alt((signed long)1, (signed long)2) == 1);
385 EATEST_VERIFY(min_alt((signed long)2, (signed long)1) == 1);
386
387 EATEST_VERIFY(min_alt((unsigned long)1, (unsigned long)1) == 1);
388 EATEST_VERIFY(min_alt((unsigned long)1, (unsigned long)2) == 1);
389 EATEST_VERIFY(min_alt((unsigned long)2, (unsigned long)1) == 1);
390
391 EATEST_VERIFY(min_alt((signed long long)1, (signed long long)1) == 1);
392 EATEST_VERIFY(min_alt((signed long long)1, (signed long long)2) == 1);
393 EATEST_VERIFY(min_alt((signed long long)2, (signed long long)1) == 1);
394
395 EATEST_VERIFY(min_alt((unsigned long long)1, (unsigned long long)1) == 1);
396 EATEST_VERIFY(min_alt((unsigned long long)1, (unsigned long long)2) == 1);
397 EATEST_VERIFY(min_alt((unsigned long long)2, (unsigned long long)1) == 1);
398
399 EATEST_VERIFY(min_alt((float)1, (float)1) == 1);
400 EATEST_VERIFY(min_alt((float)1, (float)2) == 1);
401 EATEST_VERIFY(min_alt((float)2, (float)1) == 1);
402
403 EATEST_VERIFY(min_alt((double)1, (double)1) == 1);
404 EATEST_VERIFY(min_alt((double)1, (double)2) == 1);
405 EATEST_VERIFY(min_alt((double)2, (double)1) == 1);
406
407 EATEST_VERIFY(min_alt((long double)1, (long double)1) == 1);
408 EATEST_VERIFY(min_alt((long double)1, (long double)2) == 1);
409 EATEST_VERIFY(min_alt((long double)2, (long double)1) == 1);
410
411
412 // Test max_alt specializations
413 EATEST_VERIFY(max_alt((char)1, (char)1) == 1);
414 EATEST_VERIFY(max_alt((char)1, (char)2) == 2);
415 EATEST_VERIFY(max_alt((char)2, (char)1) == 2);
416
417 EATEST_VERIFY(max_alt((signed char)1, (signed char)1) == 1);
418 EATEST_VERIFY(max_alt((signed char)1, (signed char)2) == 2);
419 EATEST_VERIFY(max_alt((signed char)2, (signed char)1) == 2);
420
421 EATEST_VERIFY(max_alt((unsigned char)1, (unsigned char)1) == 1);
422 EATEST_VERIFY(max_alt((unsigned char)1, (unsigned char)2) == 2);
423 EATEST_VERIFY(max_alt((unsigned char)2, (unsigned char)1) == 2);
424
425 EATEST_VERIFY(max_alt((signed short)1, (signed short)1) == 1);
426 EATEST_VERIFY(max_alt((signed short)1, (signed short)2) == 2);
427 EATEST_VERIFY(max_alt((signed short)2, (signed short)1) == 2);
428
429 EATEST_VERIFY(max_alt((unsigned short)1, (unsigned short)1) == 1);
430 EATEST_VERIFY(max_alt((unsigned short)1, (unsigned short)2) == 2);
431 EATEST_VERIFY(max_alt((unsigned short)2, (unsigned short)1) == 2);
432
433 EATEST_VERIFY(max_alt((signed int)1, (signed int)1) == 1);
434 EATEST_VERIFY(max_alt((signed int)1, (signed int)2) == 2);
435 EATEST_VERIFY(max_alt((signed int)2, (signed int)1) == 2);
436
437 EATEST_VERIFY(max_alt((unsigned int)1, (unsigned int)1) == 1);
438 EATEST_VERIFY(max_alt((unsigned int)1, (unsigned int)2) == 2);
439 EATEST_VERIFY(max_alt((unsigned int)2, (unsigned int)1) == 2);
440
441 EATEST_VERIFY(max_alt((signed long)1, (signed long)1) == 1);
442 EATEST_VERIFY(max_alt((signed long)1, (signed long)2) == 2);
443 EATEST_VERIFY(max_alt((signed long)2, (signed long)1) == 2);
444
445 EATEST_VERIFY(max_alt((unsigned long)1, (unsigned long)1) == 1);
446 EATEST_VERIFY(max_alt((unsigned long)1, (unsigned long)2) == 2);
447 EATEST_VERIFY(max_alt((unsigned long)2, (unsigned long)1) == 2);
448
449 EATEST_VERIFY(max_alt((signed long long)1, (signed long long)1) == 1);
450 EATEST_VERIFY(max_alt((signed long long)1, (signed long long)2) == 2);
451 EATEST_VERIFY(max_alt((signed long long)2, (signed long long)1) == 2);
452
453 EATEST_VERIFY(max_alt((unsigned long long)1, (unsigned long long)1) == 1);
454 EATEST_VERIFY(max_alt((unsigned long long)1, (unsigned long long)2) == 2);
455 EATEST_VERIFY(max_alt((unsigned long long)2, (unsigned long long)1) == 2);
456
457 EATEST_VERIFY(max_alt((float)1, (float)1) == 1);
458 EATEST_VERIFY(max_alt((float)1, (float)2) == 2);
459 EATEST_VERIFY(max_alt((float)2, (float)1) == 2);
460
461 EATEST_VERIFY(max_alt((double)1, (double)1) == 1);
462 EATEST_VERIFY(max_alt((double)1, (double)2) == 2);
463 EATEST_VERIFY(max_alt((double)2, (double)1) == 2);
464
465 EATEST_VERIFY(max_alt((long double)1, (long double)1) == 1);
466 EATEST_VERIFY(max_alt((long double)1, (long double)2) == 2);
467 EATEST_VERIFY(max_alt((long double)2, (long double)1) == 2);
468 }
469
470 {
471 // const T& min_alt(const T& a, const T& b);
472 // const T& min_alt(const T& a, const T& b, Compare compare)
473 // const T& max_alt(const T& a, const T& b);
474 // const T& max_alt(const T& a, const T& b, Compare compare)
475
476 A a1(1), a2(2), a3(3);
477 a3 = min_alt(a1, a2, LessStruct());
478 EATEST_VERIFY(a3.a == 1);
479 a3 = max_alt(a1, a2, LessStruct());
480 EATEST_VERIFY(a3.a == 2);
481
482 B b1(1), b2(2), b3(3);
483 b3 = min_alt(b2, b1, LessFunction);
484 EATEST_VERIFY(b3.b == 1);
485 b3 = max_alt(b2, b1, LessFunction);
486 EATEST_VERIFY(b3.b == 2);
487
488
489 TestObject t1(1), t2(2), t3(3);
490 t3 = min_alt(t2, t1);
491 EATEST_VERIFY(t3.mX == 1);
492 t3 = max_alt(t2, t1);
493 EATEST_VERIFY(t3.mX == 2);
494
495
496 int i1, i2(-1), i3(1);
497 i1 = min_alt(i2, i3);
498 EATEST_VERIFY(i1 == -1);
499 i1 = min_alt(i3, i2);
500 EATEST_VERIFY(i1 == -1);
501 i1 = max_alt(i2, i3);
502 EATEST_VERIFY(i1 == 1);
503 i1 = max_alt(i3, i2);
504 EATEST_VERIFY(i1 == 1);
505
506 float f1, f2(-1), f3(1);
507 f1 = min_alt(f2, f3);
508 EATEST_VERIFY(f1 == -1);
509 f1 = min_alt(f3, f2);
510 EATEST_VERIFY(f1 == -1);
511 f1 = max_alt(f2, f3);
512 EATEST_VERIFY(f1 == 1);
513 f1 = max_alt(f3, f2);
514 EATEST_VERIFY(f1 == 1);
515
516 double d1, d2(-1), d3(1);
517 d1 = min_alt(d2, d3);
518 EATEST_VERIFY(d1 == -1);
519 d1 = min_alt(d3, d2);
520 EATEST_VERIFY(d1 == -1);
521 d1 = max_alt(d2, d3);
522 EATEST_VERIFY(d1 == 1);
523 d1 = max_alt(d3, d2);
524 EATEST_VERIFY(d1 == 1);
525
526 // Make sure enums work
527 static_assert(eastl::is_enum<TestMinMaxEnum>::value, "is_enum failure");
528 EATEST_VERIFY(eastl::min(teX, teY) == teX);
529
530 // Make sure pointers work
531 TestObject testObjectArray[2];
532 EATEST_VERIFY(eastl::min(&testObjectArray[0], &testObjectArray[1]) == &testObjectArray[0]);
533
534 // Regression for Microsoft warning C4347 (http://msdn.microsoft.com/en-us/library/x7wb5te0.aspx)
535 int32_t value = rng.RandRange(17, 18);
536 int32_t result = eastl::max_alt<int32_t>(0, value); // warning C4347: behavior change: 'const T &eastl::max_alt<int32_t>(const T &,const T &)' is called instead of 'int eastl::max_alt(int,int)'
537 EATEST_VERIFY(result == 17);
538
539 // Regression for Microsoft error C2666 (http://msdn.microsoft.com/en-us/library/dyafzty4%28v=vs.110%29.aspx)
540 uint32_t value2a = 17;
541 uint32_t value2b = 2;
542 uint32_t result2 = eastl::min_alt<uint32_t>(value2a - value2b, 4); // error C2666: 'eastl::min_alt' : 12 overloads have similar conversions
543 EATEST_VERIFY(result2 == 4);
544
545 // Regression for volatile arguments + literals
546 // This test is disabled until we come up with a solution for this. std::min gives the same result as below, so we aren't necessarily obligated to resolve this.
547 // volatile uint32_t value3 = 17;
548 // uint32_t result3 = eastl::min_alt<uint32_t>(value3, 4); // error C2664: 'const T &eastl::min_alt<unsigned int>(const T &,const T &)' : cannot convert parameter 1 from 'volatile uint32_t' to 'const unsigned int &'
549 // EATEST_VERIFY(result3 == 4);
550 }
551
552
553 {
554 // ForwardIterator min_element(ForwardIterator first, ForwardIterator last)
555 // ForwardIterator min_element(ForwardIterator first, ForwardIterator last, Compare compare)
556
557 int intArray[] = { -5, 2, 1, 5, 4, 5 };
558 int* pInt = min_element(intArray, intArray + 6);
559 EATEST_VERIFY(pInt && (*pInt == -5));
560
561 pInt = min_element(intArray, intArray + 6, Greater<int>());
562 EATEST_VERIFY(pInt && (*pInt == 5));
563
564
565 TestObject toArray[] = { TestObject(7), TestObject(2), TestObject(8), TestObject(5), TestObject(4), TestObject(-12) };
566 TestObject* pTO = min_element(toArray, toArray + 6);
567 EATEST_VERIFY(pTO && (*pTO == TestObject(-12)));
568
569 pTO = min_element(toArray, toArray + 6, Greater<TestObject>());
570 EATEST_VERIFY(pTO && (*pTO == TestObject(8)));
571 }
572
573
574 {
575 // ForwardIterator max_element(ForwardIterator first, ForwardIterator last)
576 // ForwardIterator max_element(ForwardIterator first, ForwardIterator last, Compare compare)
577
578 int intArray[] = { -5, 2, 1, 5, 4, 5 };
579 int* pInt = max_element(intArray, intArray + 6);
580 EATEST_VERIFY(pInt && (*pInt == 5));
581
582 pInt = max_element(intArray, intArray + 6, less<int>());
583 EATEST_VERIFY(pInt && (*pInt == 5));
584
585
586 TestObject toArray[] = { TestObject(7), TestObject(2), TestObject(8), TestObject(5), TestObject(4), TestObject(-12) };
587 TestObject* pTO = max_element(toArray, toArray + 6);
588 EATEST_VERIFY(pTO && (*pTO == TestObject(8)));
589
590 pTO = max_element(toArray, toArray + 6, less<TestObject>());
591 EATEST_VERIFY(pTO && (*pTO == TestObject(8)));
592 }
593
594 {
595 // template <class ForwardIterator, class Compare>
596 // eastl::pair<ForwardIterator, ForwardIterator>
597 // minmax_element(ForwardIterator first, ForwardIterator last)
598 //
599 // template <class ForwardIterator, class Compare>
600 // eastl::pair<ForwardIterator, ForwardIterator>
601 // minmax_element(ForwardIterator first, ForwardIterator last, Compare compare)
602
603 int intArray[] = { 5, -2, 1, 5, 6, 5 };
604
605 eastl::pair<int*, int*> result = eastl::minmax_element(intArray, intArray + 6);
606 EATEST_VERIFY((*result.first == -2) && (*result.second == 6));
607
608
609 // template <typename T>
610 // eastl::pair<const T&, const T&>
611 // minmax(const T& a, const T& b)
612 //
613 // template <typename T, typename Compare>
614 // eastl::pair<const T&, const T&>
615 // minmax(const T& a, const T& b, Compare comp)
616
617 // The VC++ compiler is broken in such a way that it can't compile the following without generating a warning:
618 // warning C4413: 'eastl::pair<T1,T2>::first' : reference member is initialized to a temporary that doesn't persist after the constructor exits.
619 // The Microsoft standard library definition of minmax doesn't generate this warning... because that minmax is broken and non-conforming. I think they
620 // made it the way they did because of the aforementioned compiler bug.
621 // Recent versions of clang seem to generate a warning of its own. To do: we need to address this.
622 // GCC 4.8 for x86 has a compiler bug in optimized builds for this code, so we currently enable this for non-optimized builds only.
623 #if defined(EA_COMPILER_CPP11_ENABLED) && ((defined(EA_COMPILER_CLANG) && EA_COMPILER_VERSION < 302) || (defined(EA_COMPILER_GNUC) && (EA_COMPILER_VERSION >= 4007)) && !defined(__OPTIMIZE__))
624
625 int i3(3), i2(2);
626 eastl::pair<const int&, const int&> resulti = eastl::minmax(i3, i2);
627 EATEST_VERIFY_F((resulti.first == 2) && (resulti.second == 3), "minmax failure. %d %d", resulti.first, resulti.second);
628
629 char c3(3), c2(2);
630 eastl::pair<const char&, const char&> resultc = eastl::minmax(c3, c2);
631 EATEST_VERIFY_F((resultc.first == 2) && (resultc.second == 3), "minmax failure. %d %d", (int)resultc.first, (int)resultc.second);
632
633 float f3(3), f2(2);
634 eastl::pair<const float&, const float&> resultf = eastl::minmax(f3, f2);
635 EATEST_VERIFY_F((resultf.first == 2) && (resultf.second == 3), "minmax failure. %f %f", resultf.first, resultf.second);
636 #endif
637
638
639 // template <typename T>
640 // eastl::pair<T, T>
641 // minmax(std::initializer_list<T> ilist)
642 //
643 // template <typename T, class Compare>
644 // eastl::pair<T, T>
645 // minmax(std::initializer_list<T> ilist, Compare compare)
646 #if !defined(EA_COMPILER_NO_INITIALIZER_LISTS)
647 eastl::pair<int, int> result3 = eastl::minmax({3, 2});
648 EATEST_VERIFY((result3.first == 2) && (result3.second == 3));
649 #endif
650 }
651
652
653 return nErrorCount;
654 }
655
656
TestClamp()657 static int TestClamp()
658 {
659 using namespace eastl;
660
661 int nErrorCount = 0;
662
663 EATEST_VERIFY(eastl::clamp(42, 1, 100) == 42);
664 EATEST_VERIFY(eastl::clamp(-42, 1, 100) == 1);
665 EATEST_VERIFY(eastl::clamp(420, 1, 100) == 100);
666 EATEST_VERIFY(eastl::clamp(1, 1, 100) == 1);
667 EATEST_VERIFY(eastl::clamp(100, 1, 100) == 100);
668
669 EATEST_VERIFY(eastl::clamp(42.f, 1.f, 100.f, less<float>()) == 42.f);
670 EATEST_VERIFY(eastl::clamp(-42.f, 1.f, 100.f, less<float>()) == 1.f);
671 EATEST_VERIFY(eastl::clamp(420.f, 1.f, 100.f, less<float>()) == 100.f);
672 EATEST_VERIFY(eastl::clamp(1.f, 1.f, 100.f, less<float>()) == 1.f);
673 EATEST_VERIFY(eastl::clamp(100.f, 1.f, 100.f, less<float>()) == 100.f);
674
675 EATEST_VERIFY(eastl::clamp(42., 1., 100., less<double>()) == 42.);
676 EATEST_VERIFY(eastl::clamp(-42., 1., 100., less<double>()) == 1.);
677 EATEST_VERIFY(eastl::clamp(420., 1., 100., less<double>()) == 100.);
678 EATEST_VERIFY(eastl::clamp(1., 1., 100., less<double>()) == 1.);
679 EATEST_VERIFY(eastl::clamp(100., 1., 100., less<double>()) == 100.);
680
681 EATEST_VERIFY(eastl::clamp(A(42), A(1), A(100), LessStruct()).a == A(42).a);
682 EATEST_VERIFY(eastl::clamp(A(-42), A(1), A(100), LessStruct()).a == A(1).a);
683 EATEST_VERIFY(eastl::clamp(A(420), A(1), A(100), LessStruct()).a == A(100).a);
684 EATEST_VERIFY(eastl::clamp(A(1), A(1), A(100), LessStruct()).a == A(1).a);
685 EATEST_VERIFY(eastl::clamp(A(100), A(1), A(100), LessStruct()).a == A(100).a);
686
687 return nErrorCount;
688 }
689
690
691 ///////////////////////////////////////////////////////////////////////////////
692 // TestAlgorithm
693 //
TestAlgorithm()694 int TestAlgorithm()
695 {
696 using namespace eastl;
697
698 int nErrorCount = 0;
699
700 EA::UnitTest::Rand rng(EA::UnitTest::GetRandSeed());
701
702 TestObject::Reset();
703
704 nErrorCount += TestMinMax();
705 nErrorCount += TestClamp();
706
707
708 // bool all_of (InputIterator first, InputIterator last, Predicate p);
709 // bool any_of (InputIterator first, InputIterator last, Predicate p);
710 // bool none_of(InputIterator first, InputIterator last, Predicate p);
711 {
712
713 eastl::vector<int> v;
714 v.push_back(2);
715 v.push_back(4);
716 v.push_back(6);
717 v.push_back(8);
718
719 EATEST_VERIFY(eastl::all_of( v.begin(), v.end(), DivisibleBy(2)));
720 EATEST_VERIFY(eastl::any_of( v.begin(), v.end(), DivisibleBy(3)));
721 EATEST_VERIFY(eastl::none_of(v.begin(), v.end(), DivisibleBy(5)));
722 }
723
724
725 {
726 // pair mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2)
727 // pair mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Predicate predicate)
728
729 int intArray1[] = { -5, 2, 1, 5, 4, 8888 };
730 int intArray2[] = { -5, 2, 1, 5, 4, 9999 };
731 int intArray3[] = { -5, 2, 1, 5, 4, 9999 };
732
733 eastl::pair<int*, int*> pairInt = mismatch(intArray1, intArray1, intArray2);
734 EATEST_VERIFY(pairInt.first == intArray1 + 0);
735 EATEST_VERIFY(pairInt.second == intArray2 + 0);
736
737 pairInt = mismatch(intArray1, intArray1 + 6, intArray2);
738 EATEST_VERIFY(pairInt.first == intArray1 + 5);
739 EATEST_VERIFY(pairInt.second == intArray2 + 5);
740 pairInt = mismatch(intArray2, intArray2 + 6, intArray3);
741
742 EATEST_VERIFY(pairInt.first == intArray2 + 6);
743 EATEST_VERIFY(pairInt.second == intArray3 + 6);
744
745
746 pairInt = mismatch(intArray1, intArray1, intArray2, equal_to<int>());
747 EATEST_VERIFY(pairInt.first == intArray1 + 0);
748 EATEST_VERIFY(pairInt.second == intArray2 + 0);
749
750 pairInt = mismatch(intArray1, intArray1 + 6, intArray2, equal_to<int>());
751 EATEST_VERIFY(pairInt.first == intArray1 + 5);
752 EATEST_VERIFY(pairInt.second == intArray2 + 5);
753
754 pairInt = mismatch(intArray2, intArray2 + 6, intArray3, equal_to<int>());
755 EATEST_VERIFY(pairInt.first == intArray2 + 6);
756 EATEST_VERIFY(pairInt.second == intArray3 + 6);
757 }
758
759
760 {
761 // void swap(T& a, T& b)
762 // void iter_swap(ForwardIterator1 a, ForwardIterator2 b)
763
764 int intArray[] = { -5, 2, 1, 5, 4, 5 };
765
766 swap(intArray[0], intArray[4]);
767 EATEST_VERIFY(VerifySequence(intArray, intArray + 6, int(), "swap", 4, 2, 1, 5, -5, 5, -1));
768
769 iter_swap(intArray + 2, intArray + 3);
770 EATEST_VERIFY(VerifySequence(intArray, intArray + 6, int(), "iter_swap", 4, 2, 5, 1, -5, 5, -1));
771
772
773 TestObject toArray[] = { TestObject(-5), TestObject(2), TestObject(1), TestObject(5), TestObject(4), TestObject(5) };
774
775 swap(toArray[0], toArray[4]);
776 EATEST_VERIFY(toArray[0] == TestObject(4));
777 EATEST_VERIFY(toArray[4] == TestObject(-5));
778
779 iter_swap(toArray + 2, toArray + 3);
780 EATEST_VERIFY(toArray[2] == TestObject(5));
781 EATEST_VERIFY(toArray[3] == TestObject(1));
782 }
783
784
785 {
786 // ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2)
787
788 int intArray1[] = { 3, 2, 6, 5, 4, 1 };
789 int intArray2[] = { 0, 0, 0, 0, 0, 0 };
790
791 swap_ranges(intArray1, intArray1 + 6, intArray2);
792 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 6, int(), "swap_ranges", 0, 0, 0, 0, 0, 0, -1));
793 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 6, int(), "swap_ranges", 3, 2, 6, 5, 4, 1, -1));
794
795
796 TestObject toArray1[] = { TestObject(3), TestObject(2), TestObject(6), TestObject(5), TestObject(4), TestObject(1) };
797 TestObject toArray2[] = { TestObject(0), TestObject(0), TestObject(0), TestObject(0), TestObject(0), TestObject(0) };
798
799 swap_ranges(toArray1, toArray1 + 6, toArray2);
800 EATEST_VERIFY(toArray1[0] == TestObject(0));
801 EATEST_VERIFY(toArray1[5] == TestObject(0));
802 EATEST_VERIFY(toArray2[0] == TestObject(3));
803 EATEST_VERIFY(toArray2[5] == TestObject(1));
804 }
805
806
807 {
808 // ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last)
809 // ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate predicate)
810
811 int intArray[] = { 3, 2, 5, 5, 4, 1 };
812
813 int* pInt = adjacent_find(intArray + 0, intArray + 6);
814 EATEST_VERIFY(pInt == (intArray + 2));
815
816 pInt = adjacent_find(intArray + 3, intArray + 6);
817 EATEST_VERIFY(pInt == (intArray + 6)); // Verify not found
818
819
820 TestObject toArray[] = { TestObject(3), TestObject(2), TestObject(5), TestObject(5), TestObject(4), TestObject(1) };
821
822 TestObject* pTO = adjacent_find(toArray + 0, toArray + 6);
823 EATEST_VERIFY(pTO == (toArray + 2));
824
825 pTO = adjacent_find(toArray + 3, toArray + 6);
826 EATEST_VERIFY(pTO == (toArray + 6)); // Verify not found
827 }
828
829
830 {
831 // OutputIterator move(InputIterator first, InputIterator last, OutputIterator result)
832
833 int intArray1[] = { 3, 2, 6, 5, 4, 1 };
834 int intArray2[] = { 0, 0, 0, 0, 0, 0 };
835
836 move(intArray1, intArray1 + 0, intArray2);
837 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 6, int(), "move", 0, 0, 0, 0, 0, 0, -1));
838
839 move(intArray1, intArray1 + 6, intArray2);
840 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 6, int(), "move", 3, 2, 6, 5, 4, 1, -1));
841
842 move(intArray1 + 1, intArray1 + 6, intArray1 + 0); // Copy over self.
843 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 6, int(), "move", 2, 6, 5, 4, 1, 1, -1));
844 }
845
846
847 {
848 // OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result)
849
850 int intArray1[] = { 3, 2, 6, 5, 4, 1 };
851 int intArray2[] = { 0, 0, 0, 0, 0, 0 };
852
853 copy(intArray1, intArray1 + 0, intArray2);
854 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 6, int(), "copy", 0, 0, 0, 0, 0, 0, -1));
855
856 copy(intArray1, intArray1 + 6, intArray2);
857 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 6, int(), "copy", 3, 2, 6, 5, 4, 1, -1));
858
859 copy(intArray1 + 1, intArray1 + 6, intArray1 + 0); // Copy over self.
860 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 6, int(), "copy", 2, 6, 5, 4, 1, 1, -1));
861 }
862
863
864 {
865 // OutputIterator copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate predicate)
866
867 int intArray1[] = { 9, 1, 9, 9, 9, 9, 1, 1, 9, 9 };
868 int intArray2[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
869
870 copy_if(intArray1, intArray1 + 0, intArray2, bind2nd(equal_to<int>(), (int)1));
871 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 10, int(), "copy_if", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1));
872
873 copy_if(intArray1, intArray1 + 9, intArray2, bind2nd(equal_to<int>(), (int)1));
874 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 10, int(), "copy_if", 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, -1));
875
876 copy_if(intArray1 + 1, intArray1 + 9, intArray1 + 0, bind2nd(equal_to<int>(), (int)1)); // Copy over self.
877 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 10, int(), "copy_if", 1, 1, 1, 9, 9, 9, 1, 1, 9, 9, -1));
878 }
879
880
881 {
882 // OutputIterator copy_n(InputIterator first, Size count, OutputIterator result)
883
884 eastl::string in = "123456";
885 eastl::string out;
886
887 eastl::copy_n(in.begin(), 4, eastl::back_inserter(out));
888 EATEST_VERIFY(out == "1234");
889 }
890
891
892 {
893 // BidirectionalIterator2 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result)
894
895 int intArray1[] = { 3, 2, 6, 5, 4, 1 };
896 int intArray2[] = { 0, 0, 0, 0, 0, 0 };
897
898 copy_backward(intArray1, intArray1 + 0, intArray2 + 0);
899 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 6, int(), "copy_backward", 0, 0, 0, 0, 0, 0, -1));
900
901 copy_backward(intArray1, intArray1 + 6, intArray2 + 6);
902 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 6, int(), "copy_backward", 3, 2, 6, 5, 4, 1, -1));
903
904 copy_backward(intArray1, intArray1 + 5, intArray1 + 6); // Copy over self.
905 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 6, int(), "copy_backward", 3, 3, 2, 6, 5, 4, -1));
906 }
907
908
909 {
910 // OutputIterator move(InputIterator first, InputIterator last, OutputIterator result)
911 {
912 eastl::vector<eastl::string> src;
913 for(eastl_size_t i = 0; i < 4; i++)
914 src.push_back(eastl::string(1, (char8_t)('0' + i)));
915 eastl::vector<eastl::string> dest(src.size());
916
917 eastl::move(src.begin(), src.end(), dest.begin());
918 EATEST_VERIFY((dest[0] == "0") && (dest[3] == "3"));
919 EATEST_VERIFY(src[0].empty() && src[3].empty());
920 }
921
922 {
923 // BidirectionalIterator2 move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result)
924 eastl::vector<eastl::string> src;
925 for(eastl_size_t i = 0; i < 4; i++)
926 src.push_back(eastl::string(1, (char8_t)('0' + i)));
927 eastl::vector<eastl::string> dest(src.size());
928
929 eastl::move_backward(src.begin(), src.end(), dest.end());
930 EATEST_VERIFY((dest[0] == "0") && (dest[3] == "3"));
931 EATEST_VERIFY(src[0].empty() && src[3].empty());
932 }
933 }
934
935
936 {
937 // difference_type count(InputIterator first, InputIterator last, const T& value)
938
939 int intArray[] = { 1, 2, 1, 5, 4, 1 };
940 ptrdiff_t n = count(intArray, intArray + 6, 1);
941 EATEST_VERIFY(n == 3);
942
943 TestObject toArray[] = { TestObject(1), TestObject(2), TestObject(1), TestObject(5), TestObject(4), TestObject(1) };
944 n = count(toArray, toArray + 6, TestObject(1));
945 EATEST_VERIFY(n == 3);
946 }
947
948
949 {
950 // difference_type count_if(InputIterator first, InputIterator last, Predicate predicate)
951
952 int intArray[] = { 3, 2, 6, 5, 4, 1, 2, 4, 5, 4, 1, 2 };
953
954 // Count all items whose value is less than three.
955 ptrdiff_t n = count_if(intArray, intArray, bind2nd(less<int>(), (int)3)); // No-op
956 EATEST_VERIFY(n == 0);
957 n = count_if(intArray, intArray + 12, bind2nd(less<int>(), (int)3));
958 EATEST_VERIFY(n == 5);
959
960
961 // Count all items whose value is less than three.
962 TestObject toArray[] = { TestObject(1), TestObject(3), TestObject(1), TestObject(4), TestObject(2), TestObject(5) };
963
964 n = count_if(toArray, toArray, bind2nd(less<TestObject>(), TestObject(3))); // No-op
965 EATEST_VERIFY(n == 0);
966 n = count_if(toArray, toArray + 6, bind2nd(less<TestObject>(), TestObject(3)));
967 EATEST_VERIFY(n == 3);
968
969
970 // Count all items whose value is less than three.
971 slist<int> intList;
972 intList.push_front(1);
973 intList.push_front(3);
974 intList.push_front(1);
975 intList.push_front(4);
976 intList.push_front(2);
977 intList.push_front(5);
978
979 n = count_if(intList.begin(), intList.begin(), bind2nd(less<int>(), (int)3)); // No-op
980 EATEST_VERIFY(n == 0);
981 n = count_if(intList.begin(), intList.end(), bind2nd(less<int>(), (int)3));
982 EATEST_VERIFY(n == 3);
983 }
984
985
986 {
987 // void fill(ForwardIterator first, ForwardIterator last, const T& value)
988
989 vector<int> intArray(10);
990
991 EATEST_VERIFY(VerifySequence(intArray.begin(), intArray.end(), int(), "fill", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1));
992 fill(intArray.begin() + 3, intArray.begin() + 7, 4);
993 EATEST_VERIFY(VerifySequence(intArray.begin(), intArray.end(), int(), "fill", 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, -1));
994
995
996 slist<int> intList(10);
997 slist<int>::iterator first = intList.begin();
998 slist<int>::iterator last = intList.begin();
999
1000 advance(first, 3);
1001 advance(last, 7);
1002 EATEST_VERIFY(VerifySequence(intList.begin(), intList.end(), int(), "fill", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1));
1003 fill(first, last, 4);
1004 EATEST_VERIFY(VerifySequence(intList.begin(), intList.end(), int(), "fill", 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, -1));
1005
1006
1007 // Exercise specializations we have for some platform/compiler combinations
1008 // void fill(uint64_t* first, uint64_t* last, uint64_t c);
1009 // void fill( int64_t* first, int64_t* last, int64_t c);
1010 // void fill(uint32_t* first, uint32_t* last, uint32_t c);
1011 // void fill( int32_t* first, int32_t* last, int32_t c);
1012 // void fill(uint16_t* first, uint16_t* last, uint16_t c);
1013 // void fill( int16_t* first, int16_t* last, int16_t c);
1014 const eastl_size_t kMaxSize = 300;
1015 eastl::vector<uint64_t> vU64(kMaxSize, 0);
1016 eastl::vector< int64_t> vI64(kMaxSize, 0);
1017 eastl::vector<uint32_t> vU32(kMaxSize, 0);
1018 eastl::vector< int32_t> vI32(kMaxSize, 0);
1019 eastl::vector<uint16_t> vU16(kMaxSize, 0);
1020 eastl::vector< int16_t> vI16(kMaxSize, 0);
1021
1022 for(eastl_size_t i = 0; i < kMaxSize; ++i)
1023 {
1024 eastl::fill(vU64.begin(), vU64.begin() + i, UINT64_C(0x0123456789abcdef));
1025 EATEST_VERIFY(EA::StdC::Memcheck64(&vU64[0], UINT64_C(0x0123456789abcdef), i) == NULL);
1026 EA::StdC::Memset64(&vU64[0], 0, i);
1027
1028 eastl::fill(vI64.begin(), vI64.begin() + i, UINT64_C(0x0123456789abcdef));
1029 EATEST_VERIFY(EA::StdC::Memcheck64(&vI64[0], UINT64_C(0x0123456789abcdef), i) == NULL);
1030 EA::StdC::Memset64(&vI64[0], 0, i);
1031
1032 eastl::fill(vU32.begin(), vU32.begin() + i, UINT32_C(0x01234567));
1033 EATEST_VERIFY(EA::StdC::Memcheck32(&vU32[0], UINT32_C(0x01234567), i) == NULL);
1034 EA::StdC::Memset32(&vU32[0], 0, i);
1035
1036 eastl::fill(vI32.begin(), vI32.begin() + i, UINT32_C(0x01234567));
1037 EATEST_VERIFY(EA::StdC::Memcheck32(&vI32[0], UINT32_C(0x01234567), i) == NULL);
1038 EA::StdC::Memset32(&vI32[0], 0, i);
1039
1040 eastl::fill(vU16.begin(), vU16.begin() + i, UINT16_C(0x0123));
1041 EATEST_VERIFY(EA::StdC::Memcheck16(&vU16[0], UINT16_C(0x0123), i) == NULL);
1042 EA::StdC::Memset16(&vU16[0], 0, i);
1043
1044 eastl::fill(vI16.begin(), vI16.begin() + i, UINT16_C(0x0123));
1045 EATEST_VERIFY(EA::StdC::Memcheck16(&vI16[0], UINT16_C(0x0123), i) == NULL);
1046 EA::StdC::Memset16(&vI16[0], 0, i);
1047 }
1048
1049 { // Regression for user-reported compile failure.
1050 enum TestEnum { eTestValue = -1 };
1051 eastl::vector<int32_t> intArrayEnum;
1052
1053 eastl::fill<eastl::vector<int32_t>::iterator, int32_t>(intArrayEnum.begin(), intArrayEnum.end(), eTestValue);
1054 EATEST_VERIFY(intArrayEnum.size() == 0);
1055 }
1056 }
1057
1058
1059 {
1060 // OutputIterator fill_n(OutputIterator first, Size n, const T& value)
1061
1062 vector<int> intArray(10);
1063
1064 EATEST_VERIFY(VerifySequence(intArray.begin(), intArray.end(), int(), "fill_n", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1));
1065 fill_n(intArray.begin() + 3, 4, 4);
1066 EATEST_VERIFY(VerifySequence(intArray.begin(), intArray.end(), int(), "fill_n", 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, -1));
1067
1068
1069 list<int> intList(10);
1070 list<int>::iterator first = intList.begin();
1071
1072 advance(first, 3);
1073 EATEST_VERIFY(VerifySequence(intList.begin(), intList.end(), int(), "fill_n", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1));
1074 fill_n(first, 4, 4);
1075 EATEST_VERIFY(VerifySequence(intList.begin(), intList.end(), int(), "fill_n", 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, -1));
1076
1077 // Exercise specializations we have for some platform/compiler combinations
1078 // template<typename Size>
1079 // uint64_t* fill_n(uint64_t* first, Size n, uint64_t c);
1080 // int64_t* fill_n( int64_t* first, Size n, int64_t c);
1081 // uint32_t* fill_n(uint32_t* first, Size n, uint32_t c);
1082 // int32_t* fill_n( int32_t* first, Size n, int32_t c);
1083 // uint16_t* fill_n(uint16_t* first, Size n, uint16_t c);
1084 // int16_t* fill_n( int16_t* first, Size n, int16_t c);
1085 const eastl_size_t kMaxSize = 17;
1086 eastl::vector<uint64_t> vU64(kMaxSize, 0);
1087 eastl::vector< int64_t> vI64(kMaxSize, 0);
1088 eastl::vector<uint32_t> vU32(kMaxSize, 0);
1089 eastl::vector< int32_t> vI32(kMaxSize, 0);
1090 eastl::vector<uint16_t> vU16(kMaxSize, 0);
1091 eastl::vector< int16_t> vI16(kMaxSize, 0);
1092
1093 eastl::vector<uint64_t>::iterator itU64 = eastl::fill_n(vU64.begin(), kMaxSize, UINT64_C(0x0123456789abcdef));
1094 EATEST_VERIFY(EA::StdC::Memcheck64(&vU64[0], UINT64_C(0x0123456789abcdef), kMaxSize) == NULL);
1095 EATEST_VERIFY(itU64 == (vU64.begin() + kMaxSize));
1096 EA::StdC::Memset64(&vU64[0], 0, kMaxSize);
1097
1098 eastl::vector<int64_t>::iterator itI64 = eastl::fill_n(vI64.begin(), kMaxSize, UINT64_C(0x0123456789abcdef));
1099 EATEST_VERIFY(EA::StdC::Memcheck64(&vI64[0], UINT64_C(0x0123456789abcdef), kMaxSize) == NULL);
1100 EATEST_VERIFY(itI64 == (vI64.begin() + kMaxSize));
1101 EA::StdC::Memset64(&vI64[0], 0, kMaxSize);
1102
1103 eastl::vector<uint32_t>::iterator itU32 = eastl::fill_n(vU32.begin(), kMaxSize, UINT32_C(0x01234567));
1104 EATEST_VERIFY(EA::StdC::Memcheck32(&vU32[0], UINT32_C(0x01234567), kMaxSize) == NULL);
1105 EATEST_VERIFY(itU32 == (vU32.begin() + kMaxSize));
1106 EA::StdC::Memset32(&vU32[0], 0, kMaxSize);
1107
1108 eastl::vector<int32_t>::iterator itI32 = eastl::fill_n(vI32.begin(), kMaxSize, UINT32_C(0x01234567));
1109 EATEST_VERIFY(EA::StdC::Memcheck32(&vI32[0], UINT32_C(0x01234567), kMaxSize) == NULL);
1110 EATEST_VERIFY(itI32 == (vI32.begin() + kMaxSize));
1111 EA::StdC::Memset32(&vI32[0], 0, kMaxSize);
1112
1113 eastl::vector<uint16_t>::iterator itU16 = eastl::fill_n(vU16.begin(), kMaxSize, UINT16_C(0x0123));
1114 EATEST_VERIFY(EA::StdC::Memcheck16(&vU16[0], UINT16_C(0x0123), kMaxSize) == NULL);
1115 EATEST_VERIFY(itU16 == (vU16.begin() + kMaxSize));
1116 EA::StdC::Memset16(&vU16[0], 0, kMaxSize);
1117
1118 eastl::vector<int16_t>::iterator itI16 = eastl::fill_n(vI16.begin(), kMaxSize, UINT16_C(0x0123));
1119 EATEST_VERIFY(EA::StdC::Memcheck16(&vI16[0], UINT16_C(0x0123), kMaxSize) == NULL);
1120 EATEST_VERIFY(itI16 == (vI16.begin() + kMaxSize));
1121 EA::StdC::Memset16(&vI16[0], 0, kMaxSize);
1122 }
1123
1124
1125 {
1126 // InputIterator find(InputIterator first, InputIterator last, const T& value)
1127 vector<int> intArray;
1128 intArray.push_back(0);
1129 intArray.push_back(1);
1130 intArray.push_back(2);
1131 intArray.push_back(3);
1132
1133 vector<int>::iterator it = find(intArray.begin(), intArray.end(), 2);
1134 EATEST_VERIFY(it == (intArray.begin() + 2));
1135 EATEST_VERIFY(*it == 2);
1136
1137 it = find(intArray.begin(), intArray.end(), 7);
1138 EATEST_VERIFY(it == intArray.end());
1139 }
1140
1141
1142 {
1143 // InputIterator find_if(InputIterator first, InputIterator last, Predicate predicate)
1144 // InputIterator find_if_not(InputIterator first, InputIterator last, Predicate predicate)
1145
1146 int intArray[] = { 3, 2, 6, 5, 4, 1, 2, 4, 5, 4, 1, 2 };
1147
1148 // Find an item which is equal to 1.
1149 int* pInt = find_if(intArray, intArray, bind2nd(equal_to<int>(), (int)1)); // No-op
1150 EATEST_VERIFY(pInt == (intArray));
1151 pInt = find_if(intArray, intArray + 12, bind2nd(equal_to<int>(), (int)1));
1152 EATEST_VERIFY(pInt == (intArray + 5));
1153 pInt = find_if(intArray, intArray + 12, bind2nd(equal_to<int>(), (int)99));
1154 EATEST_VERIFY(pInt == (intArray + 12));
1155
1156 pInt = find_if_not(intArray, intArray + 12, bind2nd(equal_to<int>(), (int)3));
1157 EATEST_VERIFY(pInt == (intArray + 1));
1158
1159 // Find an item which is equal to 1.
1160 TestObject toArray[] = { TestObject(4), TestObject(3), TestObject(2), TestObject(1), TestObject(2), TestObject(5) };
1161
1162 TestObject* pTO = find_if(toArray, toArray, bind2nd(equal_to<TestObject>(), TestObject(1))); // No-op
1163 EATEST_VERIFY(pTO == (toArray));
1164 pTO = find_if(toArray, toArray + 6, bind2nd(equal_to<TestObject>(), TestObject(1)));
1165 EATEST_VERIFY(pTO == (toArray + 3));
1166 pTO = find_if(toArray, toArray + 6, bind2nd(equal_to<TestObject>(), TestObject(99)));
1167 EATEST_VERIFY(pTO == (toArray + 6));
1168
1169 pTO = find_if_not(toArray, toArray + 6, bind2nd(equal_to<TestObject>(), TestObject(4)));
1170 EATEST_VERIFY(pTO == (toArray + 1));
1171
1172 // Find an item which is equal to 1.
1173 slist<int> intList;
1174 intList.push_front(4);
1175 intList.push_front(3);
1176 intList.push_front(2);
1177 intList.push_front(1);
1178 intList.push_front(2);
1179 intList.push_front(5);
1180
1181 // The list is now: { 5, 2, 1, 2, 3, 4 }
1182 slist<int>::iterator it = find_if(intList.begin(), intList.begin(), bind2nd(equal_to<int>(), (int)1)); // No-op
1183 EATEST_VERIFY(it == intList.begin());
1184 it = find_if(intList.begin(), intList.end(), bind2nd(equal_to<int>(), (int)1));
1185 EATEST_VERIFY(*it == 1);
1186 it = find_if(intList.begin(), intList.end(), bind2nd(equal_to<int>(), (int)99));
1187 EATEST_VERIFY(it == intList.end());
1188
1189 it = find_if_not(intList.begin(), intList.end(), bind2nd(equal_to<int>(), (int)5));
1190 EATEST_VERIFY(*it == 2);
1191 }
1192
1193
1194 {
1195 // ForwardIterator1 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
1196 // ForwardIterator1 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate predicate)
1197
1198 int intArray1[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
1199 int intArray2[3] = { 7, 6, 5 };
1200
1201 int* pInt = find_first_of(intArray1, intArray1, intArray2, intArray2 + 3);
1202 EATEST_VERIFY(pInt == intArray1);
1203 pInt = find_first_of(intArray1, intArray1 + 10, intArray2, intArray2);
1204 EATEST_VERIFY(pInt == intArray1 + 10);
1205 pInt = find_first_of(intArray1, intArray1 + 10, intArray2, intArray2 + 3);
1206 EATEST_VERIFY(pInt == intArray1 + 5);
1207
1208 pInt = find_first_of(intArray1, intArray1, intArray2, intArray2 + 3, equal_to<int>());
1209 EATEST_VERIFY(pInt == intArray1);
1210 pInt = find_first_of(intArray1, intArray1 + 10, intArray2, intArray2, equal_to<int>());
1211 EATEST_VERIFY(pInt == intArray1 + 10);
1212 pInt = find_first_of(intArray1, intArray1 + 10, intArray2, intArray2 + 3, equal_to<int>());
1213 EATEST_VERIFY(pInt == intArray1 + 5);
1214 }
1215
1216
1217 {
1218 // ForwardIterator1 find_first_not_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
1219 // ForwardIterator1 find_first_not_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2), BinaryPredicate predicate)
1220
1221 int intArray1[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
1222 int intArray2[3] = { 0, 1, 2 };
1223
1224 int* pInt = find_first_not_of(intArray1, intArray1, intArray2, intArray2 + 3);
1225 EATEST_VERIFY(pInt == intArray1);
1226 pInt = find_first_not_of(intArray1, intArray1 + 10, intArray2, intArray2);
1227 EATEST_VERIFY(pInt == intArray1 + 0);
1228 pInt = find_first_not_of(intArray1, intArray1 + 10, intArray2, intArray2 + 3);
1229 EATEST_VERIFY(pInt == intArray1 + 3);
1230
1231 pInt = find_first_not_of(intArray1, intArray1, intArray2, intArray2 + 3, equal_to<int>());
1232 EATEST_VERIFY(pInt == intArray1);
1233 pInt = find_first_not_of(intArray1, intArray1 + 10, intArray2, intArray2, equal_to<int>());
1234 EATEST_VERIFY(pInt == intArray1 + 0);
1235 pInt = find_first_not_of(intArray1, intArray1 + 10, intArray2, intArray2 + 3, equal_to<int>());
1236 EATEST_VERIFY(pInt == intArray1 + 3);
1237 }
1238
1239
1240 {
1241 // ForwardIterator1 find_last_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
1242 // ForwardIterator1 find_last_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate predicate)
1243
1244 int intArray1[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
1245 int intArray2[3] = { 3, 4, 5 };
1246
1247 int* pInt = find_last_of(intArray1, intArray1, intArray2, intArray2 + 3);
1248 EATEST_VERIFY(pInt == intArray1);
1249 pInt = find_last_of(intArray1, intArray1 + 10, intArray2, intArray2);
1250 EATEST_VERIFY(pInt == intArray1 + 10);
1251 pInt = find_last_of(intArray1, intArray1 + 10, intArray2, intArray2 + 3);
1252 EATEST_VERIFY(pInt == intArray1 + 5);
1253
1254 pInt = find_last_of(intArray1, intArray1, intArray2, intArray2 + 3, equal_to<int>());
1255 EATEST_VERIFY(pInt == intArray1);
1256 pInt = find_last_of(intArray1, intArray1 + 10, intArray2, intArray2, equal_to<int>());
1257 EATEST_VERIFY(pInt == intArray1 + 10);
1258 pInt = find_last_of(intArray1, intArray1 + 10, intArray2, intArray2 + 3, equal_to<int>());
1259 EATEST_VERIFY(pInt == intArray1 + 5);
1260 }
1261
1262
1263 {
1264 // ForwardIterator1 find_last_not_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
1265 // ForwardIterator1 find_last_not_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2), BinaryPredicate predicate)
1266
1267 int intArray1[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
1268 int intArray2[3] = { 7, 8, 9 };
1269
1270 int* pInt = find_last_not_of(intArray1, intArray1, intArray2, intArray2 + 3);
1271 EATEST_VERIFY(pInt == intArray1);
1272 pInt = find_last_not_of(intArray1, intArray1 + 10, intArray2, intArray2);
1273 EATEST_VERIFY(pInt == intArray1 + 10);
1274 pInt = find_last_not_of(intArray1, intArray1 + 10, intArray2, intArray2 + 3);
1275 EATEST_VERIFY(pInt == intArray1 + 6);
1276
1277 pInt = find_last_not_of(intArray1, intArray1, intArray2, intArray2 + 3, equal_to<int>());
1278 EATEST_VERIFY(pInt == intArray1);
1279 pInt = find_last_not_of(intArray1, intArray1 + 10, intArray2, intArray2, equal_to<int>());
1280 EATEST_VERIFY(pInt == intArray1 + 10);
1281 pInt = find_last_not_of(intArray1, intArray1 + 10, intArray2, intArray2 + 3, equal_to<int>());
1282 EATEST_VERIFY(pInt == intArray1 + 6);
1283 }
1284
1285
1286 {
1287 // Function for_each(InputIterator first, InputIterator last, Function function)
1288
1289 deque<int> intDeque(1000);
1290 SetIncrementalIntegers<int> sii; // We define this class at the top of this file.
1291 eastl_size_t i;
1292
1293 sii = for_each(intDeque.begin(), intDeque.end(), sii);
1294 EATEST_VERIFY(sii.mX == 1000);
1295 for(i = 0; i < 1000; i++)
1296 {
1297 if(intDeque[i] != (int)i)
1298 break;
1299 }
1300 EATEST_VERIFY(i == 1000);
1301
1302
1303 array<int, 1000> intArray;
1304 sii.reset();
1305
1306 sii = for_each(intArray.begin(), intArray.end(), sii);
1307 EATEST_VERIFY(sii.mX == 1000);
1308 for(i = 0; i < 1000; i++)
1309 {
1310 if(intArray[i] != (int)i)
1311 break;
1312 }
1313 EATEST_VERIFY(i == 1000);
1314 }
1315
1316 // for_each_n
1317 {
1318 {
1319 vector<int> v = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1320 for_each_n(v.begin(), 5, [](auto& e) { e += 10; });
1321
1322 vector<int> expected = {10, 11, 12, 13, 14, 5, 6, 7, 8, 9};
1323 EATEST_VERIFY(v == expected);
1324 }
1325
1326 // verify lambda can return a result that is ignored.
1327 {
1328 vector<int> v = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1329 for_each_n(v.begin(), 5, [](auto& e) { e += 10; return 42; });
1330
1331 vector<int> expected = {10, 11, 12, 13, 14, 5, 6, 7, 8, 9};
1332 EATEST_VERIFY(v == expected);
1333 }
1334 }
1335
1336 {
1337 // void generate(ForwardIterator first, ForwardIterator last, Generator generator)
1338 // OutputIterator generate_n(OutputIterator first, Size n, Generator generator)
1339
1340 deque<int> intDeque((eastl_size_t)rng.RandRange(100, 1000));
1341 GenerateIncrementalIntegers<int> gii(0); // We define this class at the top of this file.
1342 int i, iEnd;
1343
1344 generate(intDeque.begin(), intDeque.end(), gii);
1345 for(i = 0, iEnd = (int)intDeque.size(); i < iEnd; i++)
1346 {
1347 if(intDeque[(eastl_size_t)i] != i)
1348 break;
1349 }
1350 EATEST_VERIFY(i == iEnd);
1351
1352
1353 array<int, 1000> intArray;
1354 gii.reset(0);
1355
1356 generate(intArray.begin(), intArray.end(), gii);
1357 for(i = 0; i < 1000; i++)
1358 {
1359 if(intArray[(eastl_size_t)i] != i)
1360 break;
1361 }
1362 EATEST_VERIFY(i == 1000);
1363 }
1364
1365
1366 {
1367 // OutputIterator transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation unaryOperation)
1368
1369 deque<int> intDeque((eastl_size_t)rng.RandRange(1, 1000));
1370 int i, iEnd;
1371
1372 for(i = 0, iEnd = (int)intDeque.size(); i < iEnd; i++)
1373 intDeque[(eastl_size_t)i] = 1;
1374 transform(intDeque.begin(), intDeque.begin(), intDeque.begin(), negate<int>()); // No-op
1375 EATEST_VERIFY(intDeque[0] == 1); // Verify nothing happened
1376 transform(intDeque.begin(), intDeque.end(), intDeque.begin(), negate<int>());
1377 for(i = 0, iEnd = (int)intDeque.size(); i < iEnd; i++)
1378 {
1379 if(intDeque[(eastl_size_t)i] != -1)
1380 break;
1381 }
1382 EATEST_VERIFY(i == iEnd);
1383
1384
1385 slist<TestObject> sList;
1386 for(i = 0, iEnd = rng.RandRange(1, 100); i < iEnd; i++)
1387 sList.push_front(TestObject(1));
1388 transform(sList.begin(), sList.begin(), sList.begin(), TestObjectNegate()); // No-op
1389 EATEST_VERIFY(sList.front() == TestObject(1));
1390 transform(sList.begin(), sList.end(), sList.begin(), TestObjectNegate()); // TestObjectNegate is a custom function we define for this test.
1391 slist<TestObject>::iterator it = sList.begin();
1392 for(; it != sList.end(); it++)
1393 {
1394 if(!(*it == TestObject(-1)))
1395 break;
1396 }
1397 EATEST_VERIFY(it == sList.end());
1398 }
1399
1400
1401 {
1402 // OutputIterator transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryOperation binaryOperation)
1403
1404 int intArray1[12] = { 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 };
1405 int intArray2[12] = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
1406
1407 int* pInt = transform(intArray1, intArray1, intArray2, intArray2, plus<int>());
1408 EATEST_VERIFY(pInt == intArray2);
1409 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 12, int(), "transform", 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, -1));
1410 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 12, int(), "transform", 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -1));
1411
1412 pInt = transform(intArray1, intArray1 + 12, intArray2, intArray2, plus<int>());
1413 EATEST_VERIFY(pInt == intArray2 + 12);
1414 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 12, int(), "transform", 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, -1));
1415 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 12, int(), "transform", 3, 3, 4, 4, 3, 3, 4, 4, 3, 3, 4, 4, -1));
1416 }
1417
1418
1419 {
1420 // bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
1421 // bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate predicate)
1422
1423 vector<eastl_size_t> intArray(100);
1424 list<eastl_size_t> intList(100);
1425 generate(intArray.begin(), intArray.end(), rng);
1426 copy(intArray.begin(), intArray.end(), intList.begin());
1427
1428 bool b = equal(intArray.begin(), intArray.begin(), (eastl_size_t*)NULL);
1429 EATEST_VERIFY(b);
1430 b = equal(intArray.begin(), intArray.end(), intList.begin());
1431 EATEST_VERIFY(b);
1432 intArray[50] += 1;
1433 b = equal(intArray.begin(), intArray.end(), intList.begin());
1434 EATEST_VERIFY(!b);
1435
1436 intArray[50] -= 1; // resulttore its original value so the containers are equal again.
1437 b = equal(intArray.begin(), intArray.begin(), (eastl_size_t*)NULL, equal_to<eastl_size_t>());
1438 EATEST_VERIFY(b);
1439 b = equal(intArray.begin(), intArray.end(), intList.begin(), equal_to<eastl_size_t>());
1440 EATEST_VERIFY(b);
1441 intArray[50] += 1;
1442 b = equal(intArray.begin(), intArray.end(), intList.begin(), equal_to<eastl_size_t>());
1443 EATEST_VERIFY(!b);
1444 }
1445
1446
1447 {
1448 // bool identical(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2)
1449 // bool identical(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, BinaryPredicate predicate)
1450
1451 vector<eastl_size_t> intArray(100);
1452 list<eastl_size_t> intList(100);
1453 generate(intArray.begin(), intArray.end(), rng);
1454 copy(intArray.begin(), intArray.end(), intList.begin());
1455
1456
1457 bool b = identical(intArray.begin(), intArray.begin(), (eastl_size_t*)NULL, (eastl_size_t*)NULL);
1458 EATEST_VERIFY(b);
1459 b = identical(intArray.begin(), intArray.end(), intList.begin(), intList.end());
1460 EATEST_VERIFY(b);
1461 b = identical(intArray.begin(), intArray.end() - 10, intList.begin(), intList.end());
1462 EATEST_VERIFY(!b);
1463 b = identical(intList.begin(), intList.end(), intArray.begin() + 10, intArray.end());
1464 EATEST_VERIFY(!b);
1465 intArray[50] += 1;
1466 b = identical(intArray.begin(), intArray.end(), intList.begin(), intList.end());
1467 EATEST_VERIFY(!b);
1468
1469
1470 intArray[50] -= 1; // resulttore its original value so the containers are equal again.
1471 b = identical(intArray.begin(), intArray.begin(), (eastl_size_t*)NULL, (eastl_size_t*)NULL, equal_to<eastl_size_t>());
1472 EATEST_VERIFY(b);
1473 b = identical(intArray.begin(), intArray.end(), intList.begin(), intList.end(), equal_to<eastl_size_t>());
1474 EATEST_VERIFY(b);
1475 b = identical(intArray.begin(), intArray.end() - 10, intList.begin(), intList.end(), equal_to<eastl_size_t>());
1476 EATEST_VERIFY(!b);
1477 b = identical(intList.begin(), intList.end(), intArray.begin() + 10, intArray.end(), equal_to<eastl_size_t>());
1478 EATEST_VERIFY(!b);
1479 intArray[50] += 1;
1480 b = identical(intArray.begin(), intArray.end(), intList.begin(), intList.end(), equal_to<eastl_size_t>());
1481 EATEST_VERIFY(!b);
1482 }
1483
1484
1485 {
1486 // bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2)
1487 // bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare compare)
1488
1489 int intArray1[6] = { 0, 1, 2, 3, 4, 5 };
1490 int intArray2[6] = { 0, 1, 2, 3, 4, 6 };
1491 int intArray3[5] = { 0, 1, 2, 3, 4 };
1492
1493 bool b = lexicographical_compare(intArray1, intArray1, intArray2, intArray2); // Test empty range.
1494 EATEST_VERIFY(!b);
1495 b = lexicographical_compare(intArray1, intArray1 + 6, intArray2, intArray2 + 6);
1496 EATEST_VERIFY( b);
1497 b = lexicographical_compare(intArray2, intArray2 + 6, intArray1, intArray1 + 6);
1498 EATEST_VERIFY(!b);
1499 b = lexicographical_compare(intArray1, intArray1 + 6, intArray3, intArray3 + 5);
1500 EATEST_VERIFY(!b);
1501
1502 b = lexicographical_compare(intArray1, intArray1, intArray2, intArray2, greater<int>()); // Test empty range.
1503 EATEST_VERIFY(!b);
1504 b = lexicographical_compare(intArray1, intArray1 + 6, intArray2, intArray2 + 6, greater<int>());
1505 EATEST_VERIFY(!b);
1506 b = lexicographical_compare(intArray2, intArray2 + 6, intArray1, intArray1 + 6, greater<int>());
1507 EATEST_VERIFY( b);
1508 b = lexicographical_compare(intArray3, intArray3 + 5, intArray1, intArray1 + 6, less<int>());
1509 EATEST_VERIFY( b);
1510 }
1511
1512
1513 {
1514 // ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const T& value)
1515 // ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare compare)
1516
1517 int i;
1518
1519 int* pInt = lower_bound((int*)NULL, (int*)NULL, 100);
1520 EATEST_VERIFY(pInt == NULL);
1521
1522
1523 for(i = 0; i < 20 + (gEASTL_TestLevel * 20); i++)
1524 {
1525 deque<int> intDeque((eastl_size_t)rng.RandRange(1, 500));
1526
1527 for(int j = 0, jEnd = (int)intDeque.size(); j < jEnd; j++)
1528 intDeque[(eastl_size_t)j] = (int)rng.RandLimit(jEnd / 2); // This will result in both gaps and duplications.
1529
1530 for(int k = 0, kEnd = (int)intDeque.size(); k < kEnd; k++)
1531 {
1532 deque<int>::iterator it = lower_bound(intDeque.begin(), intDeque.end(), k);
1533
1534 if(it != intDeque.begin())
1535 EATEST_VERIFY(*(it - 1) < k);
1536
1537 if(it != intDeque.end())
1538 EATEST_VERIFY((k < *it) || !(*it < k)); // Verify tha k <= *it by using only operator<
1539 }
1540 }
1541
1542
1543 for(i = 0; i < 20 + (gEASTL_TestLevel * 20); i++)
1544 {
1545 list<TestObject> toList;
1546 int nSize = (int)rng.RandRange(1, 500);
1547
1548 for(int j = 0, jEnd = nSize; j < jEnd; j++)
1549 toList.push_back(TestObject((int)rng.RandLimit(jEnd / 2))); // This will result in both gaps and duplications.
1550
1551 for(int k = 0; k < nSize; k++)
1552 {
1553 TestObject toK(k);
1554 list<TestObject>::iterator it = lower_bound(toList.begin(), toList.end(), toK);
1555
1556 if(it != toList.begin())
1557 {
1558 --it;
1559 EATEST_VERIFY(*it < toK);
1560 ++it;
1561 }
1562
1563 if(it != toList.end())
1564 EATEST_VERIFY((toK < *it) || !(*it < toK)); // Verify tha k <= *it by using only operator<
1565 }
1566 }
1567 }
1568
1569
1570 {
1571 // ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& value)
1572 // ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare compare)
1573
1574 int i;
1575
1576 int* pInt = upper_bound((int*)NULL, (int*)NULL, 100);
1577 EATEST_VERIFY(pInt == NULL);
1578
1579
1580 for(i = 0; i < 20 + (gEASTL_TestLevel * 20); i++)
1581 {
1582 deque<int> intDeque((eastl_size_t)rng.RandRange(1, 500));
1583
1584 for(eastl_size_t j = 0, jEnd = intDeque.size(); j < jEnd; j++)
1585 intDeque[j] = (int)rng.RandLimit((uint32_t)jEnd / 2); // This will result in both gaps and duplications.
1586
1587 for(int k = 0, kEnd = (int)intDeque.size(); k < kEnd; k++)
1588 {
1589 deque<int>::iterator it = upper_bound(intDeque.begin(), intDeque.end(), k);
1590
1591 if(it != intDeque.begin())
1592 EATEST_VERIFY((*(it - 1) < k) || !(k < *(it - 1))); // Verify tha *it <= k by using only operator<
1593
1594 if(it != intDeque.end())
1595 EATEST_VERIFY(k < *it);
1596 }
1597 }
1598
1599
1600 for(i = 0; i < 20 + (gEASTL_TestLevel * 20); i++)
1601 {
1602 list<TestObject> toList;
1603 int nSize = (int)rng.RandRange(1, 500);
1604
1605 for(int j = 0, jEnd = nSize; j < jEnd; j++)
1606 toList.push_back(TestObject((int)rng.RandLimit(jEnd / 2))); // This will result in both gaps and duplications.
1607
1608 for(int k = 0; k < nSize; k++)
1609 {
1610 TestObject toK(k);
1611 list<TestObject>::iterator it = upper_bound(toList.begin(), toList.end(), toK);
1612
1613 if(it != toList.begin())
1614 {
1615 --it;
1616 EATEST_VERIFY((*it < toK) || !(toK < *it)); // Verify tha *it <= k by using only operator<
1617 ++it;
1618 }
1619
1620 if(it != toList.end())
1621 EATEST_VERIFY(toK < *it);
1622 }
1623 }
1624 }
1625
1626
1627 {
1628 // pair<ForwardIterator, ForwardIterator> equal_range(ForwardIterator first, ForwardIterator last, const T& value)
1629 // pair<ForwardIterator, ForwardIterator> equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare compare)
1630
1631 int i;
1632
1633 pair<int*, int*> pInt = equal_range((int*)NULL, (int*)NULL, 100);
1634 EATEST_VERIFY(pInt.first == NULL);
1635 EATEST_VERIFY(pInt.second == NULL);
1636
1637
1638 for(i = 0; i < 20 + (gEASTL_TestLevel * 20); i++)
1639 {
1640 deque<int> intDeque((eastl_size_t)rng.RandRange(1, 500));
1641
1642 for(int j = 0, jEnd = (int)intDeque.size(); j < jEnd; j++)
1643 intDeque[(eastl_size_t)j] = (int)rng.RandLimit(jEnd / 2); // This will result in both gaps and duplications.
1644
1645 for(int k = 0, kEnd = (int)intDeque.size(); k < kEnd; k++)
1646 {
1647 pair<deque<int>::iterator, deque<int>::iterator> it = equal_range(intDeque.begin(), intDeque.end(), k);
1648
1649 // Test it.first as lower_bound.
1650 if(it.first != intDeque.begin())
1651 EATEST_VERIFY(*(it.first - 1) < k);
1652
1653 if(it.first != intDeque.end())
1654 EATEST_VERIFY((k < *it.first) || !(*it.first < k)); // Verify tha k <= *it by using only operator<
1655
1656 // Test it.second as upper_bound.
1657 if(it.second != intDeque.begin())
1658 EATEST_VERIFY((*(it.second - 1) < k) || !(k < *(it.second - 1))); // Verify tha *it <= k by using only operator<
1659
1660 if(it.second != intDeque.end())
1661 EATEST_VERIFY(k < *it.second);
1662 }
1663 }
1664
1665
1666 for(i = 0; i < 20 + (gEASTL_TestLevel * 20); i++)
1667 {
1668 list<TestObject> toList;
1669 int nSize = (int)rng.RandRange(1, 500);
1670
1671 for(int j = 0, jEnd = nSize; j < jEnd; j++)
1672 toList.push_back(TestObject((int)rng.RandLimit(jEnd / 2))); // This will result in both gaps and duplications.
1673
1674 for(int k = 0; k < nSize; k++)
1675 {
1676 TestObject toK(k);
1677 pair<list<TestObject>::iterator, list<TestObject>::iterator> it = equal_range(toList.begin(), toList.end(), toK);
1678
1679 // Test it.first as lower_bound
1680 if(it.first != toList.begin())
1681 {
1682 --it.first;
1683 EATEST_VERIFY(*it.first < toK);
1684 ++it.first;
1685 }
1686
1687 if(it.first != toList.end())
1688 EATEST_VERIFY((toK < *it.first) || !(*it.first < toK)); // Verify tha k <= *it by using only operator<
1689
1690 // Test it.second as upper_bound
1691 if(it.second != toList.begin())
1692 {
1693 --it.second;
1694 EATEST_VERIFY((*it.second < toK) || !(toK < *it.second)); // Verify tha *it <= k by using only operator<
1695 ++it.second;
1696 }
1697
1698 if(it.second != toList.end())
1699 EATEST_VERIFY(toK < *it.second);
1700 }
1701 }
1702 }
1703
1704
1705 {
1706 // void replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value)
1707 // void replace_if(ForwardIterator first, ForwardIterator last, Predicate predicate, const T& new_value)
1708
1709 int intArray[8] = { 0, 3, 2, 7, 5, 4, 5, 3, };
1710
1711 // Convert 3s to 99s.
1712 replace(intArray, intArray, 3, 99); // No-op
1713 EATEST_VERIFY((intArray[1] == 3) && (intArray[7] == 3));
1714 replace(intArray, intArray + 8, 3, 99); // No-op
1715 EATEST_VERIFY((intArray[1] == 99) && (intArray[7] == 99));
1716
1717 // Convert 99s to 88s.
1718 replace_if(intArray, intArray, bind2nd(equal_to<int>(), (int)99), 88); // No-op
1719 EATEST_VERIFY((intArray[1] == 99) && (intArray[7] == 99));
1720 replace_if(intArray, intArray + 8, bind2nd(equal_to<int>(), (int)99), 88);
1721 EATEST_VERIFY((intArray[1] == 88) && (intArray[7] == 88));
1722
1723
1724 slist<TestObject> toList;
1725 slist<TestObject>::iterator it;
1726 toList.push_front(TestObject(3));
1727 toList.push_front(TestObject(5));
1728 toList.push_front(TestObject(4));
1729 toList.push_front(TestObject(5));
1730 toList.push_front(TestObject(7));
1731 toList.push_front(TestObject(2));
1732 toList.push_front(TestObject(3));
1733 toList.push_front(TestObject(0));
1734
1735 // Convert 3s to 99s.
1736 replace(toList.begin(), toList.begin(), TestObject(3), TestObject(99)); // No-op
1737 it = toList.begin();
1738 advance(it, 1);
1739 EATEST_VERIFY(*it == TestObject(3));
1740 advance(it, 6);
1741 EATEST_VERIFY(*it == TestObject(3));
1742 replace(toList.begin(), toList.end(), TestObject(3), TestObject(99));
1743 it = toList.begin();
1744 advance(it, 1);
1745 EATEST_VERIFY(*it == TestObject(99));
1746 advance(it, 6);
1747 EATEST_VERIFY(*it == TestObject(99));
1748
1749 // Convert 99s to 88s.
1750 replace_if(toList.begin(), toList.begin(), bind2nd(equal_to<TestObject>(), TestObject(99)), TestObject(88)); // No-op
1751 it = toList.begin();
1752 advance(it, 1);
1753 EATEST_VERIFY(*it == TestObject(99));
1754 advance(it, 6);
1755 EATEST_VERIFY(*it == TestObject(99));
1756 replace_if(toList.begin(), toList.end(), bind2nd(equal_to<TestObject>(), TestObject(99)), TestObject(88));
1757 it = toList.begin();
1758 advance(it, 1);
1759 EATEST_VERIFY(*it == TestObject(88));
1760 advance(it, 6);
1761 EATEST_VERIFY(*it == TestObject(88));
1762 }
1763
1764
1765 {
1766 // OutputIterator remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value)
1767 // OutputIterator remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate predicate)
1768
1769 int intArray1[12] = { 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 };
1770 int intArray2[12] = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
1771
1772 int* pInt = remove_copy(intArray1, intArray1, intArray2, 1); // No-op
1773 EATEST_VERIFY(pInt == intArray2);
1774 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 12, int(), "remove_copy", 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, -1));
1775 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 12, int(), "remove_copy", 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -1));
1776
1777 pInt = remove_copy(intArray1, intArray1 + 12, intArray2, 1);
1778 EATEST_VERIFY(pInt == intArray2 + 6);
1779 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 12, int(), "remove_copy", 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, -1));
1780 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 12, int(), "remove_copy", 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, -1));
1781
1782
1783 pInt = remove_copy_if(intArray1, intArray1, intArray2, bind2nd(equal_to<int>(), (int)0)); // No-op
1784 EATEST_VERIFY(pInt == intArray2);
1785 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 12, int(), "remove_copy_if", 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, -1));
1786 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 12, int(), "remove_copy_if", 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, -1));
1787
1788 pInt = remove_copy_if(intArray1, intArray1 + 12, intArray2, bind2nd(equal_to<int>(), (int)0));
1789 EATEST_VERIFY(pInt == intArray2 + 6);
1790 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 12, int(), "remove_copy_if", 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, -1));
1791 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 12, int(), "remove_copy_if", 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, -1));
1792 }
1793
1794
1795 {
1796 // ForwardIterator remove(ForwardIterator first, ForwardIterator last, const T& value)
1797 // ForwardIterator remove_if(ForwardIterator first, ForwardIterator last, Predicate predicate)
1798
1799 int intArray1[12] = { 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 };
1800 int intArray2[12] = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
1801
1802 int* pInt = remove(intArray1, intArray1, 1);
1803 EATEST_VERIFY(pInt == intArray1);
1804 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 12, int(), "remove", 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, -1));
1805 pInt = remove(intArray1, intArray1 + 12, 1);
1806 EATEST_VERIFY(pInt == intArray1 + 6);
1807 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 12, int(), "remove", 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, -1));
1808
1809 pInt = remove(intArray2, intArray2, 1);
1810 EATEST_VERIFY(pInt == intArray2);
1811 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 12, int(), "remove", 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -1));
1812 pInt = remove(intArray2, intArray2 + 12, 1);
1813 EATEST_VERIFY(pInt == intArray2 + 12);
1814 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 12, int(), "remove", 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -1));
1815 }
1816
1817
1818 {
1819 // OutputIterator replace_copy(InputIterator first, InputIterator last, OutputIterator result, const T& old_value, const T& new_value)
1820 // OutputIterator replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate predicate, const T& new_value)
1821
1822 int intArray1[12] = { 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 };
1823 int intArray2[12] = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
1824
1825 int* pInt = replace_copy(intArray1, intArray1, intArray2, 1, 4);
1826 EATEST_VERIFY(pInt == intArray2);
1827 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 12, int(), "replace_copy", 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, -1));
1828 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 12, int(), "replace_copy", 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -1));
1829
1830 pInt = replace_copy(intArray1, intArray1 + 12, intArray2, 1, 4);
1831 EATEST_VERIFY(pInt == intArray2 + 12);
1832 EATEST_VERIFY(VerifySequence(intArray1, intArray1 + 12, int(), "replace_copy", 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, -1));
1833 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 12, int(), "replace_copy", 0, 0, 4, 4, 0, 0, 4, 4, 0, 0, 4, 4, -1));
1834 }
1835
1836
1837 {
1838 // void reverse(BidirectionalIterator first, BidirectionalIterator last)
1839
1840 vector<int> intArray;
1841 for(int i = 0; i < 10; i++)
1842 intArray.push_back(i);
1843
1844 reverse(intArray.begin(), intArray.begin()); // No-op
1845 EATEST_VERIFY(VerifySequence(intArray.begin(), intArray.end(), int(), "reverse", 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1));
1846
1847 reverse(intArray.begin(), intArray.end());
1848 EATEST_VERIFY(VerifySequence(intArray.begin(), intArray.end(), int(), "reverse", 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1));
1849
1850
1851 list<TestObject> toList;
1852 for(int j = 0; j < 10; j++)
1853 toList.push_back(TestObject(j));
1854
1855 reverse(toList.begin(), toList.begin()); // No-op
1856 EATEST_VERIFY(toList.front() == TestObject(0));
1857 EATEST_VERIFY(toList.back() == TestObject(9));
1858
1859 reverse(toList.begin(), toList.end());
1860 EATEST_VERIFY(toList.front() == TestObject(9));
1861 EATEST_VERIFY(toList.back() == TestObject(0));
1862
1863 // Verify that reversing an empty range executes without exception.
1864 reverse(toList.begin(), toList.begin());
1865 }
1866
1867
1868 {
1869 // reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result)
1870
1871 vector<int> intArray1;
1872 int intArray2[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };
1873
1874 for(int i = 0; i < 10; i++)
1875 intArray1.push_back(i);
1876
1877 int* pInt = reverse_copy(intArray1.begin(), intArray1.begin(), intArray2); // No-op
1878 EATEST_VERIFY(pInt == intArray2);
1879 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 10, int(), "reverse_copy", 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, -1));
1880
1881 pInt = reverse_copy(intArray1.begin(), intArray1.end(), intArray2);
1882 EATEST_VERIFY(pInt == intArray2 + intArray1.size());
1883 EATEST_VERIFY(VerifySequence(intArray2, intArray2 + 10, int(), "reverse_copy", 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1));
1884
1885
1886 list<TestObject> toList;
1887 TestObject toArray2[10];
1888
1889 for(int j = 0; j < 10; j++)
1890 {
1891 toList.push_back(TestObject(j));
1892 toArray2[j] = TestObject(5);
1893 }
1894
1895 TestObject* pTO = reverse_copy(toList.begin(), toList.begin(), toArray2); // No-op
1896 EATEST_VERIFY(pTO == toArray2);
1897 EATEST_VERIFY(toArray2[0] == TestObject(5));
1898 EATEST_VERIFY(toArray2[9] == TestObject(5));
1899
1900 pTO = reverse_copy(toList.begin(), toList.end(), toArray2);
1901 EATEST_VERIFY(pTO == toArray2 + 10);
1902 }
1903
1904
1905 {
1906 // ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
1907 // ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate predicate)
1908
1909 // Test via bidirectional/random_access iterator.
1910 basic_string<char> sTest("abcdefg abcdefg abcdefg");
1911 const char* pSubstring1 = " abcd";
1912 const char* pSubstring2 = "1234";
1913
1914 basic_string<char>::iterator iString = search(sTest.begin(), sTest.end(), pSubstring1, pSubstring1 + strlen(pSubstring1));
1915 EATEST_VERIFY(&*iString == &sTest[7]);
1916
1917 iString = search(sTest.begin(), sTest.end(), pSubstring1, pSubstring1 + 1); // Search for sequence of 1.
1918 EATEST_VERIFY(&*iString == &sTest[7]);
1919
1920 iString = search(sTest.begin(), sTest.end(), pSubstring2, pSubstring2 + strlen(pSubstring2));
1921 EATEST_VERIFY(&*iString == sTest.end());
1922
1923 iString = search(sTest.begin(), sTest.end(), pSubstring2, pSubstring2); // Search with empty search pattern.
1924 EATEST_VERIFY(&*iString == sTest.begin());
1925
1926 // Test via forward iterator.
1927 slist<char> sListTest;
1928 for(slist<char>::size_type i = sTest.size(); i > 0; --i)
1929 sListTest.push_front(sTest[i - 1]);
1930
1931 slist<char>::iterator iSlist = search(sListTest.begin(), sListTest.end(), pSubstring1, pSubstring1 + 5);
1932 slist<char>::iterator i7 = sListTest.begin();
1933 advance(i7, 7);
1934 EATEST_VERIFY(iSlist == i7);
1935
1936 iSlist = search(sListTest.begin(), sListTest.end(), pSubstring2, pSubstring2 + strlen(pSubstring2));
1937 EATEST_VERIFY(iSlist == sListTest.end());
1938
1939 iSlist = search(sListTest.begin(), sListTest.end(), pSubstring2, pSubstring2); // Search with empty search pattern.
1940 EATEST_VERIFY(iSlist == sListTest.begin());
1941 }
1942
1943
1944 {
1945 // ForwardIterator search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value)
1946
1947 const char* pString1 = "Hello wwworld";
1948 const char* presultult = search_n(pString1, pString1 + strlen(pString1), 1, 'w');
1949 EATEST_VERIFY(presultult == pString1 + 6);
1950 }
1951
1952
1953 {
1954 // bool binary_search(ForwardIterator first, ForwardIterator last, const T& value)
1955 // bool binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare compare)
1956
1957 // ForwardIterator binary_search_i(ForwardIterator first, ForwardIterator last, const T& value)
1958 // ForwardIterator binary_search_i(ForwardIterator first, ForwardIterator last, const T& value, Compare compare)
1959
1960 vector<int> intArray;
1961 for(int i = 0; i < 1000; i++)
1962 intArray.push_back(i);
1963
1964 bool b = binary_search(intArray.begin(), intArray.begin(), 0);
1965 EATEST_VERIFY(b == false);
1966
1967 b = binary_search(intArray.begin(), intArray.begin() + 1, 0);
1968 EATEST_VERIFY(b == true);
1969
1970 b = binary_search(intArray.begin(), intArray.end(), 733, less<int>());
1971 EATEST_VERIFY(b == true);
1972
1973
1974 vector<int>::iterator it = binary_search_i(intArray.begin(), intArray.begin(), 0);
1975 EATEST_VERIFY(it == intArray.begin());
1976
1977 it = binary_search_i(intArray.begin(), intArray.begin() + 1, 0, less<int>());
1978 EATEST_VERIFY(it == intArray.begin());
1979
1980 it = binary_search_i(intArray.begin(), intArray.end(), 733);
1981 EATEST_VERIFY(it == intArray.begin() + 733);
1982
1983
1984 list<TestObject> toList;
1985 list<TestObject>::iterator toI;
1986 for(int j = 0; j < 1000; j++)
1987 toList.push_back(TestObject(j));
1988
1989 b = binary_search(toList.begin(), toList.begin(), TestObject(0), less<TestObject>());
1990 EATEST_VERIFY(b == false);
1991
1992 toI = toList.begin();
1993 toI++;
1994 b = binary_search(toList.begin(), toI, TestObject(0));
1995 EATEST_VERIFY(b == true);
1996
1997 b = binary_search(toList.begin(), toList.end(), TestObject(733));
1998 EATEST_VERIFY(b == true);
1999
2000
2001 toI = binary_search_i(toList.begin(), toList.begin(), TestObject(0), less<TestObject>()); // No-op
2002 EATEST_VERIFY(toI == toList.begin());
2003
2004 toI = toList.begin();
2005 toI++;
2006 toI = binary_search_i(toList.begin(), toI, TestObject(0));
2007 EATEST_VERIFY(*toI == TestObject(0));
2008
2009 toI = binary_search_i(toList.begin(), toList.end(), TestObject(733));
2010 EATEST_VERIFY(*toI == TestObject(733));
2011 }
2012
2013
2014 {
2015 // ForwardIterator unique(ForwardIterator first, ForwardIterator last)
2016 // ForwardIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate predicate)
2017
2018 int intArray[] = { 1, 2, 3, 3, 4, 4 };
2019
2020 int* pInt = unique(intArray, intArray + 0);
2021 EATEST_VERIFY(pInt == intArray);
2022 EATEST_VERIFY(VerifySequence(intArray, intArray + 6, int(), "unique", 1, 2, 3, 3, 4, 4, -1));
2023
2024 pInt = unique(intArray, intArray + 6, equal_to<int>());
2025 EATEST_VERIFY(pInt == intArray + 4);
2026 EATEST_VERIFY(VerifySequence(intArray, intArray + 6, int(), "unique", 1, 2, 3, 4, 4, 4, -1));
2027
2028
2029 TestObject toArray[] = { TestObject(1), TestObject(2), TestObject(3), TestObject(3), TestObject(4), TestObject(4) };
2030
2031 TestObject* pTO = unique(toArray, toArray + 6);
2032 EATEST_VERIFY(pTO == toArray + 4);
2033 EATEST_VERIFY(toArray[3] == TestObject(4));
2034 }
2035
2036
2037 {
2038 // ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
2039 // ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate predicate)
2040
2041 // Test via bidirectional/random_access iterator.
2042 basic_string<char> sTest("abcdefg abcdefg abcdefg");
2043 const char* pSubstring1 = "abcd";
2044 const char* pSubstring2 = "1234";
2045
2046 basic_string<char>::iterator iString = find_end(sTest.begin(), sTest.end(), pSubstring1, pSubstring1 + 4);
2047 EATEST_VERIFY(&*iString == &sTest[16]);
2048
2049 iString = find_end(sTest.begin(), sTest.end(), pSubstring1, pSubstring1 + 4, equal_to<char>());
2050 EATEST_VERIFY(&*iString == &sTest[16]);
2051
2052 iString = find_end(sTest.begin(), sTest.end(), pSubstring2, pSubstring2 + strlen(pSubstring2));
2053 EATEST_VERIFY(iString == sTest.end());
2054
2055 iString = find_end(sTest.begin(), sTest.end(), pSubstring2, pSubstring2 + strlen(pSubstring2), equal_to<char>());
2056 EATEST_VERIFY(iString == sTest.end());
2057
2058 // Test via forward iterator.
2059 slist<char> sListTest;
2060 for(slist<char>::size_type i = sTest.size(); i > 0; --i)
2061 sListTest.push_front(sTest[i - 1]);
2062
2063 slist<char>::iterator iSlist = find_end(sListTest.begin(), sListTest.end(), pSubstring1, pSubstring1 + strlen(pSubstring1));
2064 slist<char>::iterator i16 = sListTest.begin();
2065 advance(i16, 16);
2066 EATEST_VERIFY(iSlist == i16);
2067
2068 iSlist = find_end(sListTest.begin(), sListTest.end(), pSubstring1, pSubstring1 + strlen(pSubstring1), equal_to<char>());
2069 i16 = sListTest.begin();
2070 advance(i16, 16);
2071 EATEST_VERIFY(iSlist == i16);
2072
2073 iSlist = find_end(sListTest.begin(), sListTest.end(), pSubstring2, pSubstring2 + strlen(pSubstring2));
2074 EATEST_VERIFY(iSlist == sListTest.end());
2075
2076 iSlist = find_end(sListTest.begin(), sListTest.end(), pSubstring2, pSubstring2 + strlen(pSubstring2), equal_to<char>());
2077 EATEST_VERIFY(iSlist == sListTest.end());
2078 }
2079
2080
2081 {
2082 // OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
2083 // OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare compare)
2084
2085 int intArray1[] = { 0, 0, 2, 5, 8, 8, 12, 24, 26, 43 };
2086 int intArray2[] = { 0, 0, 0, 5, 7, 8, 11, 24, 25, 43 };
2087 int intArray3[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
2088
2089 set_difference(intArray1, intArray1 + 0, intArray2, intArray2 + 0, intArray3);
2090 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 10, int(), "set_difference", 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, -1));
2091
2092 set_difference(intArray1, intArray1 + 10, intArray2, intArray2 + 10, intArray3);
2093 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 10, int(), "set_difference", 2, 8, 12, 26, 9, 9, 9, 9, 9, 9, -1));
2094
2095 intArray3[0] = intArray3[1] = intArray3[2] = 9;
2096
2097 set_difference(intArray1, intArray1 + 10, intArray2, intArray2 + 10, intArray3, less<int>());
2098 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 10, int(), "set_difference", 2, 8, 12, 26, 9, 9, 9, 9, 9, 9, -1));
2099 }
2100
2101
2102 {
2103 // OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
2104 // OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare compare)
2105
2106 int intArray1[] = { 0, 0, 2, 5, 8, 8, 12, 24, 26, 43 };
2107 int intArray2[] = { 0, 0, 0, 5, 7, 8, 11, 24, 25, 43 };
2108 int intArray3[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
2109
2110 set_symmetric_difference(intArray1, intArray1 + 0, intArray2, intArray2 + 0, intArray3);
2111 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 10, int(), "set_symmetric_difference", 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, -1));
2112
2113 set_symmetric_difference(intArray1, intArray1 + 10, intArray2, intArray2 + 10, intArray3);
2114 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 10, int(), "set_symmetric_difference", 0, 2, 7, 8, 11, 12, 25, 26, 9, 9, -1));
2115
2116 intArray3[0] = intArray3[1] = intArray3[2] = intArray3[4] = intArray3[5] = intArray3[6] = 9;
2117
2118 set_symmetric_difference(intArray1, intArray1 + 10, intArray2, intArray2 + 10, intArray3, less<int>());
2119 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 10, int(), "set_symmetric_difference", 0, 2, 7, 8, 11, 12, 25, 26, 9, 9, -1));
2120 }
2121
2122
2123 {
2124 // OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
2125 // OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare compare)
2126
2127 int intArray1[] = { 0, 0, 2, 5, 8, 8, 12, 24, 26, 43 };
2128 int intArray2[] = { 0, 0, 0, 5, 7, 8, 11, 24, 25, 43 };
2129 int intArray3[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
2130
2131 set_intersection(intArray1, intArray1 + 0, intArray2, intArray2 + 0, intArray3);
2132 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 10, int(), "set_intersection", 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, -1));
2133
2134 set_intersection(intArray1, intArray1 + 10, intArray2, intArray2 + 10, intArray3);
2135 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 10, int(), "set_intersection", 0, 0, 5, 8, 24, 43, 9, 9, 9, 9, -1));
2136
2137 intArray3[0] = intArray3[1] = intArray3[2] = intArray3[4] = intArray3[5] = intArray3[6] = 9;
2138
2139 set_intersection(intArray1, intArray1 + 10, intArray2, intArray2 + 10, intArray3, less<int>());
2140 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 10, int(), "set_intersection", 0, 0, 5, 8, 24, 43, 9, 9, 9, 9, -1));
2141 }
2142
2143
2144 {
2145 // OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
2146 // OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare compare)
2147
2148 int intArray1[] = { 0, 0, 2, 5, 8, 8, 12, 24, 26, 43 };
2149 int intArray2[] = { 0, 0, 0, 5, 7, 8, 11, 24, 25, 43 };
2150 int intArray3[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
2151
2152 set_union(intArray1, intArray1 + 0, intArray2, intArray2 + 0, intArray3);
2153 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 20, int(), "set_union", 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, -1));
2154
2155 set_union(intArray1, intArray1 + 10, intArray2, intArray2 + 10, intArray3);
2156 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 20, int(), "set_union", 0, 0, 0, 2, 5, 7, 8, 8, 11, 12, 24, 25, 26, 43, 9, 9, 9, 9, 9, 9, -1));
2157
2158 intArray3[0] = intArray3[1] = intArray3[2] = intArray3[3] = intArray3[4] = intArray3[5] = intArray3[6] = intArray3[7] = intArray3[8] = intArray3[9] = intArray3[10] = intArray3[11] = 9;
2159
2160 set_union(intArray1, intArray1 + 10, intArray2, intArray2 + 10, intArray3, less<int>());
2161 EATEST_VERIFY(VerifySequence(intArray3, intArray3 + 20, int(), "set_union", 0, 0, 0, 2, 5, 7, 8, 8, 11, 12, 24, 25, 26, 43, 9, 9, 9, 9, 9, 9, -1));
2162 }
2163
2164
2165 {
2166 // template<typename ForwardIterator1, typename ForwardIterator2>
2167 // bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2)
2168
2169 // template<typename ForwardIterator1, typename ForwardIterator2, class BinaryPredicate>
2170 // bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, BinaryPredicate predicate)
2171 EASTLTest_Rand eastlRNG(EA::UnitTest::GetRandSeed());
2172
2173 {
2174 int intArray1[] = { 0, 1, 2, 3, 4 };
2175 int intArray2[] = { 0, 1, 2, 3, 4 };
2176
2177 // Test an empty set.
2178 EATEST_VERIFY(eastl::is_permutation(intArray1, intArray1 + 0, intArray2));
2179
2180 // Test two identical sets.
2181 EATEST_VERIFY(eastl::is_permutation(intArray1, intArray1 + EAArrayCount(intArray1), intArray2));
2182 eastl::random_shuffle(intArray1, intArray1 + EAArrayCount(intArray1), eastlRNG);
2183
2184 // Test order randomization.
2185 EATEST_VERIFY(eastl::is_permutation(intArray1, intArray1 + EAArrayCount(intArray1), intArray2));
2186 eastl::random_shuffle(intArray2, intArray2 + EAArrayCount(intArray2), eastlRNG);
2187 EATEST_VERIFY(eastl::is_permutation(intArray1, intArray1 + EAArrayCount(intArray1), intArray2));
2188
2189 // Test the case where there's a difference.
2190 intArray2[4] = intArray2[3]; // This change guarantees is_permutation will return false.
2191 EATEST_VERIFY(!eastl::is_permutation(intArray1, intArray1 + EAArrayCount(intArray1), intArray2));
2192 }
2193
2194 {
2195 int intArray1[] = { 0, 0, 0, 1, 1 };
2196 int intArray2[] = { 0, 0, 0, 1, 1 };
2197
2198 // Test two identical sets.
2199 EATEST_VERIFY(eastl::is_permutation(intArray1, intArray1 + EAArrayCount(intArray1), intArray2));
2200 eastl::random_shuffle(intArray1, intArray1 + EAArrayCount(intArray1), eastlRNG);
2201
2202 // Test order randomization.
2203 EATEST_VERIFY(eastl::is_permutation(intArray1, intArray1 + EAArrayCount(intArray1), intArray2));
2204 eastl::random_shuffle(intArray2, intArray2 + EAArrayCount(intArray2), eastlRNG);
2205 EATEST_VERIFY(eastl::is_permutation(intArray1, intArray1 + EAArrayCount(intArray1), intArray2));
2206
2207 // Test the case where there's a difference.
2208 intArray2[4] = (intArray2[4] == 0) ? 1 : 0;
2209 EATEST_VERIFY(!eastl::is_permutation(intArray1, intArray1 + EAArrayCount(intArray1), intArray2));
2210 }
2211
2212 for(int n = 0; n < 100000; n++)
2213 {
2214 eastl_size_t intArray1[6];
2215 eastl_size_t intArray2[6];
2216
2217 for(size_t i = 0; i < EAArrayCount(intArray1); i++)
2218 {
2219 intArray1[i] = eastlRNG.RandLimit(6);
2220 intArray2[i] = eastlRNG.RandLimit(6);
2221 }
2222
2223 bool isPermutation = eastl::is_permutation(intArray1, intArray1 + EAArrayCount(intArray1), intArray2);
2224
2225 // If is_permutation returned true, then sorted versions of the two arrays should be identical.
2226 eastl::sort(intArray1, intArray1 + EAArrayCount(intArray1));
2227 eastl::sort(intArray2, intArray2 + EAArrayCount(intArray2));
2228
2229 eastl::pair<eastl_size_t*, eastl_size_t*> mismatchResult = eastl::mismatch(intArray1, intArray1 + EAArrayCount(intArray1), intArray2);
2230 bool isIdentical = (mismatchResult.first == (intArray1 + EAArrayCount(intArray1)));
2231
2232 EATEST_VERIFY(isPermutation == isIdentical); // With an array size of 6, isPermutation ends up being true about 1 in 400 times here.
2233 }
2234 }
2235
2236 {
2237 //template<typename BidirectionalIterator>
2238 //bool next_permutation(BidirectionalIterator first, BidirectionalIterator last);
2239
2240 //template<typename BidirectionalIterator, typename Compare>
2241 //bool next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare compare);
2242
2243 uint64_t count;
2244 vector<int> intArray;
2245 for(int i = 0; i < 8; i++)
2246 intArray.push_back(i);
2247
2248 count = 0;
2249 do {
2250 ++count;
2251 } while(next_permutation(intArray.begin(), intArray.end()));
2252 EATEST_VERIFY(count == 40320); // count = n!
2253 EATEST_VERIFY(is_sorted(intArray.begin(), intArray.end()));
2254
2255 count = 0;
2256 do {
2257 ++count;
2258 } while(next_permutation(intArray.begin(), intArray.end(), eastl::less<int>()));
2259 EATEST_VERIFY(count == 40320); // count = n!
2260 EATEST_VERIFY(is_sorted(intArray.begin(), intArray.end()));
2261 }
2262
2263
2264 {
2265 // template <typename ForwardIterator>
2266 // ForwardIterator rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
2267
2268 // eastl::array (ContiguousIterator/Pointer)
2269 const eastl_size_t kRotateArraySize = 10;
2270 typedef eastl::array<int, kRotateArraySize> IntArray;
2271
2272 { // This type is templated, so we can't run a loop over various sizes.
2273 IntArray intArray;
2274
2275 for(eastl_size_t i = 0; i < kRotateArraySize; i++)
2276 {
2277 eastl::generate_n(intArray.begin(), kRotateArraySize, GenerateIncrementalIntegers<int>());
2278 IntArray::iterator intArrayItMiddle = eastl::next(intArray.begin(), i);
2279 IntArray::iterator intArrayIt = eastl::rotate(intArray.begin(), intArrayItMiddle, intArray.end());
2280
2281 for(eastl_size_t j = 0; j < kRotateArraySize; j++)
2282 {
2283 if(intArrayIt == intArray.end())
2284 intArrayIt = intArray.begin();
2285 EATEST_VERIFY(*intArrayIt++ == (int)j);
2286 }
2287 }
2288 }
2289
2290 // eastl::vector (ContiguousIterator)
2291 typedef eastl::vector<int> IntVector;
2292
2293 for(eastl_size_t s = 10; s < 500; s += (eastl_size_t)rng.RandRange(50, 100))
2294 {
2295 IntVector intVector(s, 0);
2296
2297 for(eastl_size_t i = 0; i < s; i++)
2298 {
2299 eastl::generate_n(intVector.begin(), s, GenerateIncrementalIntegers<int>());
2300 IntVector::iterator intVectorItMiddle = eastl::next(intVector.begin(), i);
2301 IntVector::iterator intVectorIt = eastl::rotate(intVector.begin(), intVectorItMiddle, intVector.end());
2302
2303 for(eastl_size_t j = 0; j < s; j++)
2304 {
2305 if(intVectorIt == intVector.end())
2306 intVectorIt = intVector.begin();
2307 EATEST_VERIFY(*intVectorIt++ == (int)j);
2308 }
2309 }
2310 }
2311
2312 // eastl::deque (RandomAccessIterator)
2313 typedef eastl::deque<int> IntDeque;
2314
2315 for(eastl_size_t s = 10; s < 500; s += (eastl_size_t)rng.RandRange(50, 100))
2316 {
2317 IntDeque intDeque(s, 0);
2318
2319 for(eastl_size_t i = 0; i < s; i++)
2320 {
2321 eastl::generate_n(intDeque.begin(), s, GenerateIncrementalIntegers<int>());
2322 IntDeque::iterator intDequeItMiddle = eastl::next(intDeque.begin(), i);
2323 IntDeque::iterator intDequeIt = eastl::rotate(intDeque.begin(), intDequeItMiddle, intDeque.end());
2324
2325 for(eastl_size_t j = 0; j < s; j++)
2326 {
2327 if(intDequeIt == intDeque.end())
2328 intDequeIt = intDeque.begin();
2329 EATEST_VERIFY(*intDequeIt++ == (int)j);
2330 }
2331 }
2332 }
2333
2334 // eastl::list (BidirectionalIterator)
2335 typedef eastl::list<int> IntList;
2336
2337 for(eastl_size_t s = 10; s < 500; s += (eastl_size_t)rng.RandRange(50, 100))
2338 {
2339 IntList intList(s, 0);
2340
2341 for(eastl_size_t i = 0; i < s; i++)
2342 {
2343 eastl::generate_n(intList.begin(), s, GenerateIncrementalIntegers<int>());
2344 IntList::iterator intListItMiddle = eastl::next(intList.begin(), i);
2345 IntList::iterator intListIt = eastl::rotate(intList.begin(), intListItMiddle, intList.end());
2346
2347 for(eastl_size_t j = 0; j < s; j++)
2348 {
2349 if(intListIt == intList.end())
2350 intListIt = intList.begin();
2351 EATEST_VERIFY(*intListIt++ == (int)j);
2352 }
2353 }
2354 }
2355
2356 // eastl::slist (ForwardIterator)
2357 typedef eastl::slist<int> IntSlist;
2358
2359 for(eastl_size_t s = 10; s < 500; s += (eastl_size_t)rng.RandRange(50, 100))
2360 {
2361 IntSlist intSlist(s, 0);
2362
2363 for(eastl_size_t i = 0; i < s; i++)
2364 {
2365 eastl::generate_n(intSlist.begin(), s, GenerateIncrementalIntegers<int>());
2366 IntSlist::iterator intSlistItMiddle = eastl::next(intSlist.begin(), i);
2367 IntSlist::iterator intSlistIt = eastl::rotate(intSlist.begin(), intSlistItMiddle, intSlist.end());
2368
2369 for(eastl_size_t j = 0; j < s; j++)
2370 {
2371 if(intSlistIt == intSlist.end())
2372 intSlistIt = intSlist.begin();
2373 EATEST_VERIFY(*intSlistIt++ == (int)j);
2374 }
2375 }
2376 }
2377 }
2378
2379 // test eastl::sort with move-only type
2380 {
2381 {
2382 eastl::vector<eastl::unique_ptr<int>> vec;
2383 eastl::sort(vec.begin(), vec.end(), [](const eastl::unique_ptr<int>& lhs, const eastl::unique_ptr<int>& rhs) { return *lhs < *rhs; });
2384 }
2385 {
2386 eastl::vector<eastl::unique_ptr<int>> vec;
2387 eastl::sort(vec.begin(), vec.end());
2388 }
2389 {
2390 eastl::vector<MissingMoveConstructor> vec;
2391 eastl::sort(vec.begin(), vec.end(), [](const MissingMoveConstructor& lhs, const MissingMoveConstructor& rhs) { return lhs < rhs; });
2392 }
2393 {
2394 eastl::vector<MissingMoveConstructor> vec;
2395 eastl::sort(vec.begin(), vec.end());
2396 }
2397 {
2398 eastl::vector<MissingMoveAssignable> vec;
2399 eastl::sort(vec.begin(), vec.end(), [](const MissingMoveAssignable& lhs, const MissingMoveAssignable& rhs) { return lhs < rhs; });
2400 }
2401 {
2402 eastl::vector<MissingMoveAssignable> vec;
2403 eastl::sort(vec.begin(), vec.end());
2404 }
2405 {
2406 eastl::vector<eastl::unique_ptr<int>> vec;
2407 vec.emplace_back(new int(7));
2408 vec.emplace_back(new int(-42));
2409 vec.emplace_back(new int(5));
2410 eastl::sort(vec.begin(), vec.end(), [](const eastl::unique_ptr<int>& lhs, const eastl::unique_ptr<int>& rhs) { return *lhs < *rhs; });
2411 EATEST_VERIFY(*vec[0] == -42);
2412 EATEST_VERIFY(*vec[1] == 5);
2413 EATEST_VERIFY(*vec[2] == 7);
2414 }
2415 {
2416 for (unsigned tests = 0; tests < 50; ++tests)
2417 {
2418 eastl::vector<eastl::unique_ptr<int>> vec1;
2419
2420 for (int i = 0; i < 100; ++i)
2421 {
2422 int randomNumber = rng();
2423 vec1.emplace_back(new int(randomNumber));
2424 }
2425
2426 auto vec1Cmp = [](const eastl::unique_ptr<int>& lhs, const eastl::unique_ptr<int>& rhs) { return *lhs < *rhs; };
2427 eastl::sort(vec1.begin(), vec1.end(), vec1Cmp);
2428 EATEST_VERIFY(eastl::is_sorted(vec1.begin(), vec1.end(), vec1Cmp));
2429 }
2430 }
2431 }
2432
2433 EATEST_VERIFY(TestObject::IsClear());
2434 TestObject::Reset();
2435
2436 return nErrorCount;
2437 }
2438