1bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant//===----------------------------------------------------------------------===// 2bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 3f5256e16dfc425c1d466f6308d4026d529ce9e0bHoward Hinnant// The LLVM Compiler Infrastructure 4bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 5b64f8b07c104c6cc986570ac8ee0ed16a9f23976Howard Hinnant// This file is dual licensed under the MIT and the University of Illinois Open 6b64f8b07c104c6cc986570ac8ee0ed16a9f23976Howard Hinnant// Source Licenses. See LICENSE.TXT for details. 7bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// 8bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant//===----------------------------------------------------------------------===// 9bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 10bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// <algorithm> 11bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 12eb564e76cc3904d811c981a50ecce0659f444cc9Howard Hinnant// template<ShuffleIterator Iter> 13bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// Iter 14bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant// rotate(Iter first, Iter middle, Iter last); 15bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 16bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <algorithm> 17bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <cassert> 1873d21a4f0774d3fadab98e690619a359cfb160a3Howard Hinnant#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 19bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#include <memory> 20bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant#endif 21bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 2283e2c4d877fe2d7793868b1c6a5d9525a7c4d431Marshall Clow#include "test_iterators.h" 23bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 24bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnanttemplate <class Iter> 25bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantvoid 26bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnanttest() 27bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant{ 28bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant int ia[] = {0}; 29bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned sa = sizeof(ia)/sizeof(ia[0]); 30bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant Iter r = std::rotate(Iter(ia), Iter(ia), Iter(ia)); 31bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ia); 32bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ia[0] == 0); 33bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ia), Iter(ia), Iter(ia+sa)); 34bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ia+sa); 35bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ia[0] == 0); 36bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ia), Iter(ia+sa), Iter(ia+sa)); 37bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ia); 38bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ia[0] == 0); 39bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 40bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant int ib[] = {0, 1}; 41bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned sb = sizeof(ib)/sizeof(ib[0]); 42bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ib), Iter(ib), Iter(ib+sb)); 43bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ib+sb); 44bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ib[0] == 0); 45bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ib[1] == 1); 46bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ib), Iter(ib+1), Iter(ib+sb)); 47bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ib+1); 48bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ib[0] == 1); 49bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ib[1] == 0); 50bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ib), Iter(ib+sb), Iter(ib+sb)); 51bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ib); 52bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ib[0] == 1); 53bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ib[1] == 0); 54bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 55bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant int ic[] = {0, 1, 2}; 56bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned sc = sizeof(ic)/sizeof(ic[0]); 57bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ic), Iter(ic), Iter(ic+sc)); 58bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ic+sc); 59bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[0] == 0); 60bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[1] == 1); 61bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[2] == 2); 62bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ic), Iter(ic+1), Iter(ic+sc)); 63bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ic+2); 64bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[0] == 1); 65bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[1] == 2); 66bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[2] == 0); 67bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ic), Iter(ic+2), Iter(ic+sc)); 68bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ic+1); 69bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[0] == 0); 70bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[1] == 1); 71bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[2] == 2); 72bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ic), Iter(ic+sc), Iter(ic+sc)); 73bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ic); 74bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[0] == 0); 75bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[1] == 1); 76bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ic[2] == 2); 77bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 78bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant int id[] = {0, 1, 2, 3}; 79bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned sd = sizeof(id)/sizeof(id[0]); 80bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(id), Iter(id), Iter(id+sd)); 81bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == id+sd); 82bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[0] == 0); 83bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[1] == 1); 84bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[2] == 2); 85bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[3] == 3); 86bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(id), Iter(id+1), Iter(id+sd)); 87bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == id+3); 88bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[0] == 1); 89bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[1] == 2); 90bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[2] == 3); 91bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[3] == 0); 92bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(id), Iter(id+2), Iter(id+sd)); 93bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == id+2); 94bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[0] == 3); 95bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[1] == 0); 96bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[2] == 1); 97bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[3] == 2); 98bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(id), Iter(id+3), Iter(id+sd)); 99bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == id+1); 100bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[0] == 2); 101bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[1] == 3); 102bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[2] == 0); 103bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[3] == 1); 104bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(id), Iter(id+sd), Iter(id+sd)); 105bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == id); 106bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[0] == 2); 107bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[1] == 3); 108bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[2] == 0); 109bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(id[3] == 1); 110bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 111bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant int ie[] = {0, 1, 2, 3, 4}; 112bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned se = sizeof(ie)/sizeof(ie[0]); 113bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie), Iter(ie+se)); 114bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie+se); 115bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[0] == 0); 116bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[1] == 1); 117bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[2] == 2); 118bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[3] == 3); 119bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[4] == 4); 120bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie+1), Iter(ie+se)); 121bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie+4); 122bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[0] == 1); 123bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[1] == 2); 124bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[2] == 3); 125bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[3] == 4); 126bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[4] == 0); 127bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie+2), Iter(ie+se)); 128bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie+3); 129bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[0] == 3); 130bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[1] == 4); 131bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[2] == 0); 132bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[3] == 1); 133bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[4] == 2); 134bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie+3), Iter(ie+se)); 135bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie+2); 136bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[0] == 1); 137bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[1] == 2); 138bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[2] == 3); 139bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[3] == 4); 140bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[4] == 0); 141bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie+4), Iter(ie+se)); 142bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie+1); 143bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[0] == 0); 144bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[1] == 1); 145bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[2] == 2); 146bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[3] == 3); 147bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[4] == 4); 148bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie+se), Iter(ie+se)); 149bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie); 150bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[0] == 0); 151bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[1] == 1); 152bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[2] == 2); 153bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[3] == 3); 154bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ie[4] == 4); 155bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 156bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant int ig[] = {0, 1, 2, 3, 4, 5}; 157bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned sg = sizeof(ig)/sizeof(ig[0]); 158bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig), Iter(ig+sg)); 159bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+sg); 160bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[0] == 0); 161bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[1] == 1); 162bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[2] == 2); 163bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[3] == 3); 164bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[4] == 4); 165bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[5] == 5); 166bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+1), Iter(ig+sg)); 167bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+5); 168bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[0] == 1); 169bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[1] == 2); 170bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[2] == 3); 171bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[3] == 4); 172bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[4] == 5); 173bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[5] == 0); 174bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+2), Iter(ig+sg)); 175bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+4); 176bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[0] == 3); 177bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[1] == 4); 178bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[2] == 5); 179bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[3] == 0); 180bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[4] == 1); 181bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[5] == 2); 182bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+3), Iter(ig+sg)); 183bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+3); 184bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[0] == 0); 185bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[1] == 1); 186bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[2] == 2); 187bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[3] == 3); 188bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[4] == 4); 189bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[5] == 5); 190bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+4), Iter(ig+sg)); 191bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+2); 192bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[0] == 4); 193bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[1] == 5); 194bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[2] == 0); 195bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[3] == 1); 196bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[4] == 2); 197bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[5] == 3); 198bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+5), Iter(ig+sg)); 199bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+1); 200bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[0] == 3); 201bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[1] == 4); 202bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[2] == 5); 203bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[3] == 0); 204bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[4] == 1); 205bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[5] == 2); 206bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+sg), Iter(ig+sg)); 207bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig); 208bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[0] == 3); 209bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[1] == 4); 210bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[2] == 5); 211bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[3] == 0); 212bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[4] == 1); 213bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(ig[5] == 2); 214bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant} 215bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 21673d21a4f0774d3fadab98e690619a359cfb160a3Howard Hinnant#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 217bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 218bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnanttemplate <class Iter> 219bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantvoid 220bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnanttest1() 221bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant{ 222bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::unique_ptr<int> ia[1]; 223bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned sa = sizeof(ia)/sizeof(ia[0]); 224bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant for (int i = 0; i < sa; ++i) 225bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ia[i].reset(new int(i)); 226bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant Iter r = std::rotate(Iter(ia), Iter(ia), Iter(ia)); 227bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ia); 228bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ia[0] == 0); 229bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ia), Iter(ia), Iter(ia+sa)); 230bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ia+sa); 231bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ia[0] == 0); 232bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ia), Iter(ia+sa), Iter(ia+sa)); 233bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ia); 234bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ia[0] == 0); 235bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 236bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::unique_ptr<int> ib[2]; 237bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned sb = sizeof(ib)/sizeof(ib[0]); 238bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant for (int i = 0; i < sb; ++i) 239bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ib[i].reset(new int(i)); 240bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ib), Iter(ib), Iter(ib+sb)); 241bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ib+sb); 242bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ib[0] == 0); 243bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ib[1] == 1); 244bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ib), Iter(ib+1), Iter(ib+sb)); 245bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ib+1); 246bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ib[0] == 1); 247bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ib[1] == 0); 248bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ib), Iter(ib+sb), Iter(ib+sb)); 249bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ib); 250bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ib[0] == 1); 251bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ib[1] == 0); 252bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 253bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::unique_ptr<int> ic[3]; 254bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned sc = sizeof(ic)/sizeof(ic[0]); 255bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant for (int i = 0; i < sc; ++i) 256bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ic[i].reset(new int(i)); 257bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ic), Iter(ic), Iter(ic+sc)); 258bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ic+sc); 259bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[0] == 0); 260bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[1] == 1); 261bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[2] == 2); 262bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ic), Iter(ic+1), Iter(ic+sc)); 263bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ic+2); 264bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[0] == 1); 265bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[1] == 2); 266bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[2] == 0); 267bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ic), Iter(ic+2), Iter(ic+sc)); 268bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ic+1); 269bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[0] == 0); 270bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[1] == 1); 271bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[2] == 2); 272bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ic), Iter(ic+sc), Iter(ic+sc)); 273bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ic); 274bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[0] == 0); 275bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[1] == 1); 276bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ic[2] == 2); 277bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 278bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::unique_ptr<int> id[4]; 279bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned sd = sizeof(id)/sizeof(id[0]); 280bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant for (int i = 0; i < sd; ++i) 281bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant id[i].reset(new int(i)); 282bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(id), Iter(id), Iter(id+sd)); 283bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == id+sd); 284bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[0] == 0); 285bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[1] == 1); 286bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[2] == 2); 287bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[3] == 3); 288bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(id), Iter(id+1), Iter(id+sd)); 289bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == id+3); 290bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[0] == 1); 291bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[1] == 2); 292bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[2] == 3); 293bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[3] == 0); 294bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(id), Iter(id+2), Iter(id+sd)); 295bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == id+2); 296bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[0] == 3); 297bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[1] == 0); 298bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[2] == 1); 299bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[3] == 2); 300bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(id), Iter(id+3), Iter(id+sd)); 301bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == id+1); 302bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[0] == 2); 303bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[1] == 3); 304bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[2] == 0); 305bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[3] == 1); 306bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(id), Iter(id+sd), Iter(id+sd)); 307bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == id); 308bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[0] == 2); 309bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[1] == 3); 310bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[2] == 0); 311bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*id[3] == 1); 312bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 313bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::unique_ptr<int> ie[5]; 314bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned se = sizeof(ie)/sizeof(ie[0]); 315bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant for (int i = 0; i < se; ++i) 316bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ie[i].reset(new int(i)); 317bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie), Iter(ie+se)); 318bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie+se); 319bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[0] == 0); 320bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[1] == 1); 321bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[2] == 2); 322bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[3] == 3); 323bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[4] == 4); 324bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie+1), Iter(ie+se)); 325bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie+4); 326bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[0] == 1); 327bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[1] == 2); 328bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[2] == 3); 329bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[3] == 4); 330bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[4] == 0); 331bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie+2), Iter(ie+se)); 332bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie+3); 333bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[0] == 3); 334bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[1] == 4); 335bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[2] == 0); 336bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[3] == 1); 337bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[4] == 2); 338bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie+3), Iter(ie+se)); 339bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie+2); 340bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[0] == 1); 341bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[1] == 2); 342bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[2] == 3); 343bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[3] == 4); 344bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[4] == 0); 345bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie+4), Iter(ie+se)); 346bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie+1); 347bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[0] == 0); 348bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[1] == 1); 349bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[2] == 2); 350bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[3] == 3); 351bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[4] == 4); 352bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ie), Iter(ie+se), Iter(ie+se)); 353bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ie); 354bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[0] == 0); 355bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[1] == 1); 356bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[2] == 2); 357bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[3] == 3); 358bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ie[4] == 4); 359bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 360bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant std::unique_ptr<int> ig[6]; 361bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant const unsigned sg = sizeof(ig)/sizeof(ig[0]); 362bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant for (int i = 0; i < sg; ++i) 363bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant ig[i].reset(new int(i)); 364bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig), Iter(ig+sg)); 365bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+sg); 366bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[0] == 0); 367bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[1] == 1); 368bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[2] == 2); 369bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[3] == 3); 370bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[4] == 4); 371bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[5] == 5); 372bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+1), Iter(ig+sg)); 373bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+5); 374bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[0] == 1); 375bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[1] == 2); 376bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[2] == 3); 377bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[3] == 4); 378bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[4] == 5); 379bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[5] == 0); 380bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+2), Iter(ig+sg)); 381bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+4); 382bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[0] == 3); 383bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[1] == 4); 384bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[2] == 5); 385bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[3] == 0); 386bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[4] == 1); 387bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[5] == 2); 388bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+3), Iter(ig+sg)); 389bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+3); 390bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[0] == 0); 391bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[1] == 1); 392bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[2] == 2); 393bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[3] == 3); 394bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[4] == 4); 395bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[5] == 5); 396bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+4), Iter(ig+sg)); 397bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+2); 398bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[0] == 4); 399bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[1] == 5); 400bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[2] == 0); 401bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[3] == 1); 402bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[4] == 2); 403bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[5] == 3); 404bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+5), Iter(ig+sg)); 405bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig+1); 406bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[0] == 3); 407bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[1] == 4); 408bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[2] == 5); 409bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[3] == 0); 410bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[4] == 1); 411bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[5] == 2); 412bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant r = std::rotate(Iter(ig), Iter(ig+sg), Iter(ig+sg)); 413bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(base(r) == ig); 414bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[0] == 3); 415bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[1] == 4); 416bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[2] == 5); 417bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[3] == 0); 418bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[4] == 1); 419bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant assert(*ig[5] == 2); 420bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant} 421bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 42273d21a4f0774d3fadab98e690619a359cfb160a3Howard Hinnant#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 423bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 424bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnantint main() 425bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant{ 426bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant test<forward_iterator<int*> >(); 427bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant test<bidirectional_iterator<int*> >(); 428bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant test<random_access_iterator<int*> >(); 429bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant test<int*>(); 430bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 43173d21a4f0774d3fadab98e690619a359cfb160a3Howard Hinnant#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 432bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 433bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant test1<forward_iterator<std::unique_ptr<int>*> >(); 434bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant test1<bidirectional_iterator<std::unique_ptr<int>*> >(); 435bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant test1<random_access_iterator<std::unique_ptr<int>*> >(); 436bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant test1<std::unique_ptr<int>*>(); 437bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant 43873d21a4f0774d3fadab98e690619a359cfb160a3Howard Hinnant#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 439bc8d3f97eb5c958007f2713238472e0c1c8fe02Howard Hinnant} 440