LineageOS/android_external_libcxx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libcxx initial import

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@103490 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant
2010-05-11 19:42:16 +00:00
commit bc8d3f97eb
3893 changed files with 1209942 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
test/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp Normal file
View File

@@ -0,0 +1,82 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template<class Category, class T, class Distance = ptrdiff_t,
// class Pointer = T*, class Reference = T&>
// struct iterator
// {
// typedef T value_type;
// typedef Distance difference_type;
// typedef Pointer pointer;
// typedef Reference reference;
// typedef Category iterator_category;
// };
#include <iterator>
#include <type_traits>
struct A {};
template <class T>
void
test2()
{
typedef std::iterator<std::forward_iterator_tag, T> It;
static_assert((std::is_same<typename It::value_type, T>::value), "");
static_assert((std::is_same<typename It::difference_type, std::ptrdiff_t>::value), "");
static_assert((std::is_same<typename It::pointer, T*>::value), "");
static_assert((std::is_same<typename It::reference, T&>::value), "");
static_assert((std::is_same<typename It::iterator_category, std::forward_iterator_tag>::value), "");
}
template <class T>
void
test3()
{
typedef std::iterator<std::bidirectional_iterator_tag, T, short> It;
static_assert((std::is_same<typename It::value_type, T>::value), "");
static_assert((std::is_same<typename It::difference_type, short>::value), "");
static_assert((std::is_same<typename It::pointer, T*>::value), "");
static_assert((std::is_same<typename It::reference, T&>::value), "");
static_assert((std::is_same<typename It::iterator_category, std::bidirectional_iterator_tag>::value), "");
}
template <class T>
void
test4()
{
typedef std::iterator<std::random_access_iterator_tag, T, int, const T*> It;
static_assert((std::is_same<typename It::value_type, T>::value), "");
static_assert((std::is_same<typename It::difference_type, int>::value), "");
static_assert((std::is_same<typename It::pointer, const T*>::value), "");
static_assert((std::is_same<typename It::reference, T&>::value), "");
static_assert((std::is_same<typename It::iterator_category, std::random_access_iterator_tag>::value), "");
}
template <class T>
void
test5()
{
typedef std::iterator<std::input_iterator_tag, T, long, const T*, const T&> It;
static_assert((std::is_same<typename It::value_type, T>::value), "");
static_assert((std::is_same<typename It::difference_type, long>::value), "");
static_assert((std::is_same<typename It::pointer, const T*>::value), "");
static_assert((std::is_same<typename It::reference, const T&>::value), "");
static_assert((std::is_same<typename It::iterator_category, std::input_iterator_tag>::value), "");
}
int main()
{
test2<A>();
test3<A>();
test4<A>();
test5<A>();
}

45
test/iterators/iterator.primitives/iterator.operations/advance.pass.cpp Normal file
View File

@@ -0,0 +1,45 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template <InputIterator Iter>
// void advance(Iter& i, Iter::difference_type n);
//
// template <BidirectionalIterator Iter>
// void advance(Iter& i, Iter::difference_type n);
//
// template <RandomAccessIterator Iter>
// void advance(Iter& i, Iter::difference_type n);
#include <iterator>
#include <cassert>
#include "../../iterators.h"
template <class It>
void
test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
std::advance(i, n);
assert(i == x);
}
int main()
{
const char* s = "1234567890";
test(input_iterator<const char*>(s), 10, input_iterator<const char*>(s+10));
test(forward_iterator<const char*>(s), 10, forward_iterator<const char*>(s+10));
test(bidirectional_iterator<const char*>(s+5), 5, bidirectional_iterator<const char*>(s+10));
test(bidirectional_iterator<const char*>(s+5), -5, bidirectional_iterator<const char*>(s));
test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
test(random_access_iterator<const char*>(s+5), -5, random_access_iterator<const char*>(s));
test(s+5, 5, s+10);
test(s+5, -5, s);
}

40
test/iterators/iterator.primitives/iterator.operations/distance.pass.cpp Normal file
View File

@@ -0,0 +1,40 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template <InputIterator Iter>
// Iter::difference_type
// distance(Iter first, Iter last);
//
// template <RandomAccessIterator Iter>
// Iter::difference_type
// distance(Iter first, Iter last);
#include <iterator>
#include <cassert>
#include "../../iterators.h"
template <class It>
void
test(It first, It last, typename std::iterator_traits<It>::difference_type x)
{
assert(std::distance(first, last) == x);
}
int main()
{
const char* s = "1234567890";
test(input_iterator<const char*>(s), input_iterator<const char*>(s+10), 10);
test(forward_iterator<const char*>(s), forward_iterator<const char*>(s+10), 10);
test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+10), 10);
test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+10), 10);
test(s, s+10, 10);
}

46
test/iterators/iterator.primitives/iterator.operations/next.pass.cpp Normal file
View File

@@ -0,0 +1,46 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template <InputIterator Iter>
// Iter next(Iter x, Iter::difference_type n = 1);
#include <iterator>
#include <cassert>
#include "../../iterators.h"
template <class It>
void
test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
assert(std::next(i, n) == x);
}
template <class It>
void
test(It i, It x)
{
assert(std::next(i) == x);
}
int main()
{
const char* s = "1234567890";
test(forward_iterator<const char*>(s), 10, forward_iterator<const char*>(s+10));
test(bidirectional_iterator<const char*>(s), 10, bidirectional_iterator<const char*>(s+10));
test(random_access_iterator<const char*>(s), 10, random_access_iterator<const char*>(s+10));
test(s, 10, s+10);
test(forward_iterator<const char*>(s), forward_iterator<const char*>(s+1));
test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+1));
test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1));
test(s, s+1);
}

44
test/iterators/iterator.primitives/iterator.operations/prev.pass.cpp Normal file
View File

@@ -0,0 +1,44 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template <BidirectionalIterator Iter>
// Iter prev(Iter x, Iter::difference_type n = 1);
#include <iterator>
#include <cassert>
#include "../../iterators.h"
template <class It>
void
test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
assert(std::prev(i, n) == x);
}
template <class It>
void
test(It i, It x)
{
assert(std::prev(i) == x);
}
int main()
{
const char* s = "1234567890";
test(bidirectional_iterator<const char*>(s+10), 10, bidirectional_iterator<const char*>(s));
test(random_access_iterator<const char*>(s+10), 10, random_access_iterator<const char*>(s));
test(s+10, 10, s);
test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s));
test(s+1, s);
}

35
test/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp Normal file
View File

@@ -0,0 +1,35 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template<class T>
// struct iterator_traits<const T*>
// {
// typedef ptrdiff_t difference_type;
// typedef T value_type;
// typedef const T* pointer;
// typedef const T& reference;
// typedef random_access_iterator_tag iterator_category;
// };
#include <iterator>
#include <type_traits>
struct A {};
int main()
{
typedef std::iterator_traits<const A*> It;
static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
static_assert((std::is_same<It::value_type, A>::value), "");
static_assert((std::is_same<It::pointer, const A*>::value), "");
static_assert((std::is_same<It::reference, const A&>::value), "");
static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
}

26
test/iterators/iterator.primitives/iterator.traits/empty.pass.cpp Normal file
View File

@@ -0,0 +1,26 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template<class NotAnIterator>
// struct iterator_traits
// {
// };
#include <iterator>
struct not_an_iterator
{
};
int main()
{
typedef std::iterator_traits<not_an_iterator> It;
}

43
test/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp Normal file
View File

@@ -0,0 +1,43 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template<class Iter>
// struct iterator_traits
// {
// typedef typename Iter::difference_type difference_type;
// typedef typename Iter::value_type value_type;
// typedef typename Iter::pointer pointer;
// typedef typename Iter::reference reference;
// typedef typename Iter::iterator_category iterator_category;
// };
#include <iterator>
#include <type_traits>
struct A {};
struct test_iterator
{
typedef int difference_type;
typedef A value_type;
typedef A* pointer;
typedef A& reference;
typedef std::forward_iterator_tag iterator_category;
};
int main()
{
typedef std::iterator_traits<test_iterator> It;
static_assert((std::is_same<It::difference_type, int>::value), "");
static_assert((std::is_same<It::value_type, A>::value), "");
static_assert((std::is_same<It::pointer, A*>::value), "");
static_assert((std::is_same<It::iterator_category, std::forward_iterator_tag>::value), "");
}

35
test/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp Normal file
View File

@@ -0,0 +1,35 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template<class T>
// struct iterator_traits<T*>
// {
// typedef ptrdiff_t difference_type;
// typedef T value_type;
// typedef T* pointer;
// typedef T& reference;
// typedef random_access_iterator_tag iterator_category;
// };
#include <iterator>
#include <type_traits>
struct A {};
int main()
{
typedef std::iterator_traits<A*> It;
static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
static_assert((std::is_same<It::value_type, A>::value), "");
static_assert((std::is_same<It::pointer, A*>::value), "");
static_assert((std::is_same<It::reference, A&>::value), "");
static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
}

12
test/iterators/iterator.primitives/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

24
test/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp Normal file
View File

@@ -0,0 +1,24 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// struct bidirectional_iterator_tag : public forward_iterator_tag {};
#include <iterator>
#include <type_traits>
int main()
{
std::bidirectional_iterator_tag tag;
static_assert((std::is_base_of<std::forward_iterator_tag,
std::bidirectional_iterator_tag>::value), "");
static_assert((!std::is_base_of<std::output_iterator_tag,
std::bidirectional_iterator_tag>::value), "");
}

24
test/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp Normal file
View File

@@ -0,0 +1,24 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// struct forward_iterator_tag: public input_iterator_tag {};
#include <iterator>
#include <type_traits>
int main()
{
std::forward_iterator_tag tag;
static_assert((std::is_base_of<std::input_iterator_tag,
std::forward_iterator_tag>::value), "");
static_assert((!std::is_base_of<std::output_iterator_tag,
std::forward_iterator_tag>::value), "");
}

22
test/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp Normal file
View File

@@ -0,0 +1,22 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// struct input_iterator_tag {};
#include <iterator>
#include <type_traits>
int main()
{
std::input_iterator_tag tag;
static_assert((!std::is_base_of<std::output_iterator_tag,
std::input_iterator_tag>::value), "");
}

22
test/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp Normal file
View File

@@ -0,0 +1,22 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// struct output_iterator_tag {};
#include <iterator>
#include <type_traits>
int main()
{
std::output_iterator_tag tag;
static_assert((!std::is_base_of<std::input_iterator_tag,
std::output_iterator_tag>::value), "");
}

24
test/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp Normal file
View File

@@ -0,0 +1,24 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// struct random_access_iterator_tag : public bidirectional_iterator_tag {};
#include <iterator>
#include <type_traits>
int main()
{
std::random_access_iterator_tag tag;
static_assert((std::is_base_of<std::bidirectional_iterator_tag,
std::random_access_iterator_tag>::value), "");
static_assert((!std::is_base_of<std::output_iterator_tag,
std::random_access_iterator_tag>::value), "");
}

12
test/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/iterator.requirements/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/iterator.synopsis/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/iterators.general/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

251
test/iterators/iterators.h Normal file
View File

@@ -0,0 +1,251 @@
#ifndef ITERATORS_H
#define ITERATORS_H
#include <iterator>
template <class It>
class input_iterator
{
It it_;
template <class U> friend class input_iterator;
public:
typedef std::input_iterator_tag iterator_category;
typedef typename std::iterator_traits<It>::value_type value_type;
typedef typename std::iterator_traits<It>::difference_type difference_type;
typedef It pointer;
typedef typename std::iterator_traits<It>::reference reference;
It base() const {return it_;}
input_iterator() : it_() {}
explicit input_iterator(It it) : it_(it) {}
template <class U>
input_iterator(const input_iterator<U>& u) :it_(u.it_) {}
reference operator*() const {return *it_;}
pointer operator->() const {return it_;}
input_iterator& operator++() {++it_; return *this;}
input_iterator operator++(int)
{input_iterator tmp(*this); ++(*this); return tmp;}
friend bool operator==(const input_iterator& x, const input_iterator& y)
{return x.it_ == y.it_;}
friend bool operator!=(const input_iterator& x, const input_iterator& y)
{return !(x == y);}
};
template <class T, class U>
inline
bool
operator==(const input_iterator<T>& x, const input_iterator<U>& y)
{
return x.base() == y.base();
}
template <class T, class U>
inline
bool
operator!=(const input_iterator<T>& x, const input_iterator<U>& y)
{
return !(x == y);
}
template <class It>
class forward_iterator
{
It it_;
template <class U> friend class forward_iterator;
public:
typedef std::forward_iterator_tag iterator_category;
typedef typename std::iterator_traits<It>::value_type value_type;
typedef typename std::iterator_traits<It>::difference_type difference_type;
typedef It pointer;
typedef typename std::iterator_traits<It>::reference reference;
It base() const {return it_;}
forward_iterator() : it_() {}
explicit forward_iterator(It it) : it_(it) {}
template <class U>
forward_iterator(const forward_iterator<U>& u) :it_(u.it_) {}
reference operator*() const {return *it_;}
pointer operator->() const {return it_;}
forward_iterator& operator++() {++it_; return *this;}
forward_iterator operator++(int)
{forward_iterator tmp(*this); ++(*this); return tmp;}
friend bool operator==(const forward_iterator& x, const forward_iterator& y)
{return x.it_ == y.it_;}
friend bool operator!=(const forward_iterator& x, const forward_iterator& y)
{return !(x == y);}
};
template <class T, class U>
inline
bool
operator==(const forward_iterator<T>& x, const forward_iterator<U>& y)
{
return x.base() == y.base();
}
template <class T, class U>
inline
bool
operator!=(const forward_iterator<T>& x, const forward_iterator<U>& y)
{
return !(x == y);
}
template <class It>
class bidirectional_iterator
{
It it_;
template <class U> friend class bidirectional_iterator;
public:
typedef std::bidirectional_iterator_tag iterator_category;
typedef typename std::iterator_traits<It>::value_type value_type;
typedef typename std::iterator_traits<It>::difference_type difference_type;
typedef It pointer;
typedef typename std::iterator_traits<It>::reference reference;
It base() const {return it_;}
bidirectional_iterator() : it_() {}
explicit bidirectional_iterator(It it) : it_(it) {}
template <class U>
bidirectional_iterator(const bidirectional_iterator<U>& u) :it_(u.it_) {}
reference operator*() const {return *it_;}
pointer operator->() const {return it_;}
bidirectional_iterator& operator++() {++it_; return *this;}
bidirectional_iterator operator++(int)
{bidirectional_iterator tmp(*this); ++(*this); return tmp;}
bidirectional_iterator& operator--() {--it_; return *this;}
bidirectional_iterator operator--(int)
{bidirectional_iterator tmp(*this); --(*this); return tmp;}
};
template <class T, class U>
inline
bool
operator==(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
{
return x.base() == y.base();
}
template <class T, class U>
inline
bool
operator!=(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
{
return !(x == y);
}
template <class It>
class random_access_iterator
{
It it_;
template <class U> friend class random_access_iterator;
public:
typedef std::random_access_iterator_tag iterator_category;
typedef typename std::iterator_traits<It>::value_type value_type;
typedef typename std::iterator_traits<It>::difference_type difference_type;
typedef It pointer;
typedef typename std::iterator_traits<It>::reference reference;
It base() const {return it_;}
random_access_iterator() : it_() {}
explicit random_access_iterator(It it) : it_(it) {}
template <class U>
random_access_iterator(const random_access_iterator<U>& u) :it_(u.it_) {}
reference operator*() const {return *it_;}
pointer operator->() const {return it_;}
random_access_iterator& operator++() {++it_; return *this;}
random_access_iterator operator++(int)
{random_access_iterator tmp(*this); ++(*this); return tmp;}
random_access_iterator& operator--() {--it_; return *this;}
random_access_iterator operator--(int)
{random_access_iterator tmp(*this); --(*this); return tmp;}
random_access_iterator& operator+=(difference_type n) {it_ += n; return *this;}
random_access_iterator operator+(difference_type n) const
{random_access_iterator tmp(*this); tmp += n; return tmp;}
friend random_access_iterator operator+(difference_type n, random_access_iterator x)
{x += n; return x;}
random_access_iterator& operator-=(difference_type n) {return *this += -n;}
random_access_iterator operator-(difference_type n) const
{random_access_iterator tmp(*this); tmp -= n; return tmp;}
reference operator[](difference_type n) const {return it_[n];}
};
template <class T, class U>
inline
bool
operator==(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
return x.base() == y.base();
}
template <class T, class U>
inline
bool
operator!=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
return !(x == y);
}
template <class T, class U>
inline
bool
operator<(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
return x.base() < y.base();
}
template <class T, class U>
inline
bool
operator<=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
return !(y < x);
}
template <class T, class U>
inline
bool
operator>(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
return y < x;
}
template <class T, class U>
inline
bool
operator>=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
return !(x < y);
}
template <class T, class U>
inline
typename std::iterator_traits<T>::difference_type
operator-(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
return x.base() - y.base();
}
#endif

24
test/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp Normal file
View File

@@ -0,0 +1,24 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// back_insert_iterator
// explicit back_insert_iterator(Cont& x);
// test for explicit
#include <iterator>
#include <vector>
int main()
{
std::back_insert_iterator<std::vector<int> > i = std::vector<int>();
}

29
test/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp Normal file
View File

@@ -0,0 +1,29 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// back_insert_iterator
// explicit back_insert_iterator(Cont& x);
#include <iterator>
#include <vector>
template <class C>
void
test(C c)
{
std::back_insert_iterator<C> i(c);
}
int main()
{
test(std::vector<int>());
}

34
test/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp Normal file
View File

@@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// back_insert_iterator
// back_insert_iterator<Cont> operator++(int);
#include <iterator>
#include <vector>
#include <cassert>
template <class C>
void
test(C c)
{
std::back_insert_iterator<C> i(c);
std::back_insert_iterator<C> r = i++;
r = 0;
assert(c.size() == 1);
assert(c.back() == 0);
}
int main()
{
test(std::vector<int>());
}

32
test/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp Normal file
View File

@@ -0,0 +1,32 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// back_insert_iterator
// back_insert_iterator<Cont>& operator++();
#include <iterator>
#include <vector>
#include <cassert>
template <class C>
void
test(C c)
{
std::back_insert_iterator<C> i(c);
std::back_insert_iterator<C>& r = ++i;
assert(&r == &i);
}
int main()
{
test(std::vector<int>());
}

46
test/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp Normal file
View File

@@ -0,0 +1,46 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// back_insert_iterator
// requires CopyConstructible<Cont::value_type>
// back_insert_iterator<Cont>&
// operator=(const Cont::value_type& value);
#include <iterator>
#include <vector>
#include <cassert>
template <class C>
void
test(C c)
{
const typename C::value_type v = typename C::value_type();
std::back_insert_iterator<C> i(c);
i = v;
assert(c.back() == v);
}
class Copyable
{
int data_;
public:
Copyable() : data_(0) {}
~Copyable() {data_ = -1;}
friend bool operator==(const Copyable& x, const Copyable& y)
{return x.data_ == y.data_;}
};
int main()
{
test(std::vector<Copyable>());
}

42
test/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp Normal file
View File

@@ -0,0 +1,42 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// back_insert_iterator
// requires CopyConstructible<Cont::value_type>
// back_insert_iterator<Cont>&
// operator=(Cont::value_type&& value);
#include <iterator>
#ifdef _LIBCPP_MOVE
#include <vector>
#include <memory>
#include <cassert>
template <class C>
void
test(C c)
{
std::back_insert_iterator<C> i(c);
i = typename C::value_type();
assert(c.back() == typename C::value_type());
}
#endif
int main()
{
#ifdef _LIBCPP_MOVE
test(std::vector<std::unique_ptr<int> >());
#endif
}

32
test/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp Normal file
View File

@@ -0,0 +1,32 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// back_insert_iterator
// back_insert_iterator<Cont>& operator*();
#include <iterator>
#include <vector>
#include <cassert>
template <class C>
void
test(C c)
{
std::back_insert_iterator<C> i(c);
std::back_insert_iterator<C>& r = *i;
assert(&r == &i);
}
int main()
{
test(std::vector<int>());
}

33
test/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp Normal file
View File

@@ -0,0 +1,33 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template <BackInsertionContainer Cont>
// back_insert_iterator<Cont>
// back_inserter(Cont& x);
#include <iterator>
#include <vector>
#include <cassert>
template <class C>
void
test(C c)
{
std::back_insert_iterator<C> i = std::back_inserter(c);
i = 0;
assert(c.size() == 1);
assert(c.back() == 0);
}
int main()
{
test(std::vector<int>());
}

12
test/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

59
test/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp Normal file
View File

@@ -0,0 +1,59 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// back_insert_iterator
// Test nested types and data member:
// template <BackInsertionContainer Cont>
// class back_insert_iterator {
// protected:
// Cont* container;
// public:
// typedef Cont container_type;
// typedef void value_type;
// typedef void difference_type;
// typedef back_insert_iterator<Cont>& reference;
// typedef void pointer;
// };
#include <iterator>
#include <type_traits>
#include <vector>
template <class C>
struct find_container
: private std::back_insert_iterator<C>
{
explicit find_container(C& c) : std::back_insert_iterator<C>(c) {}
void test() {this->container = 0;}
};
template <class C>
void
test()
{
typedef std::back_insert_iterator<C> R;
C c;
find_container<C> q(c);
q.test();
static_assert((std::is_same<typename R::container_type, C>::value), "");
static_assert((std::is_same<typename R::value_type, void>::value), "");
static_assert((std::is_same<typename R::difference_type, void>::value), "");
static_assert((std::is_same<typename R::reference, R&>::value), "");
static_assert((std::is_same<typename R::pointer, void>::value), "");
static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
}
int main()
{
test<std::vector<int> >();
}

24
test/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp Normal file
View File

@@ -0,0 +1,24 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// front_insert_iterator
// explicit front_insert_iterator(Cont& x);
// test for explicit
#include <iterator>
#include <list>
int main()
{
std::front_insert_iterator<std::list<int> > i = std::list<int>();
}

29
test/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp Normal file
View File

@@ -0,0 +1,29 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// front_insert_iterator
// explicit front_insert_iterator(Cont& x);
#include <iterator>
#include <list>
template <class C>
void
test(C c)
{
std::front_insert_iterator<C> i(c);
}
int main()
{
test(std::list<int>());
}

34
test/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp Normal file
View File

@@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// front_insert_iterator
// front_insert_iterator<Cont> operator++(int);
#include <iterator>
#include <list>
#include <cassert>
template <class C>
void
test(C c)
{
std::front_insert_iterator<C> i(c);
std::front_insert_iterator<C> r = i++;
r = 0;
assert(c.size() == 1);
assert(c.back() == 0);
}
int main()
{
test(std::list<int>());
}

32
test/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp Normal file
View File

@@ -0,0 +1,32 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// front_insert_iterator
// front_insert_iterator<Cont>& operator++();
#include <iterator>
#include <list>
#include <cassert>
template <class C>
void
test(C c)
{
std::front_insert_iterator<C> i(c);
std::front_insert_iterator<C>& r = ++i;
assert(&r == &i);
}
int main()
{
test(std::list<int>());
}

45
test/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp Normal file
View File

@@ -0,0 +1,45 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// front_insert_iterator
// front_insert_iterator<Cont>&
// operator=(const Cont::value_type& value);
#include <iterator>
#include <list>
#include <cassert>
template <class C>
void
test(C c)
{
const typename C::value_type v = typename C::value_type();
std::front_insert_iterator<C> i(c);
i = v;
assert(c.front() == v);
}
class Copyable
{
int data_;
public:
Copyable() : data_(0) {}
~Copyable() {data_ = -1;}
friend bool operator==(const Copyable& x, const Copyable& y)
{return x.data_ == y.data_;}
};
int main()
{
test(std::list<Copyable>());
}

41
test/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp Normal file
View File

@@ -0,0 +1,41 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// front_insert_iterator
// front_insert_iterator<Cont>&
// operator=(Cont::value_type&& value);
#include <iterator>
#ifdef _LIBCPP_MOVE
#include <list>
#include <memory>
#include <cassert>
template <class C>
void
test(C c)
{
std::front_insert_iterator<C> i(c);
i = typename C::value_type();
assert(c.front() == typename C::value_type());
}
#endif
int main()
{
#ifdef _LIBCPP_MOVE
test(std::list<std::unique_ptr<int> >());
#endif
}

32
test/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp Normal file
View File

@@ -0,0 +1,32 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// front_insert_iterator
// front_insert_iterator<Cont>& operator*();
#include <iterator>
#include <list>
#include <cassert>
template <class C>
void
test(C c)
{
std::front_insert_iterator<C> i(c);
std::front_insert_iterator<C>& r = *i;
assert(&r == &i);
}
int main()
{
test(std::list<int>());
}

33
test/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp Normal file
View File

@@ -0,0 +1,33 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template <BackInsertionContainer Cont>
// front_insert_iterator<Cont>
// front_inserter(Cont& x);
#include <iterator>
#include <list>
#include <cassert>
template <class C>
void
test(C c)
{
std::front_insert_iterator<C> i = std::front_inserter(c);
i = 0;
assert(c.size() == 1);
assert(c.front() == 0);
}
int main()
{
test(std::list<int>());
}

12
test/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

60
test/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp Normal file
View File

@@ -0,0 +1,60 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// front_insert_iterator
// Test nested types and data member:
// template <class Container>
// class front_insert_iterator {
// protected:
// Container* container;
// public:
// typedef Container container_type;
// typedef void value_type;
// typedef void difference_type;
// typedef front_insert_iterator<Cont>& reference;
// typedef void pointer;
// typedef output_iterator_tag iterator_category;
// };
#include <iterator>
#include <type_traits>
#include <vector>
template <class C>
struct find_container
: private std::front_insert_iterator<C>
{
explicit find_container(C& c) : std::front_insert_iterator<C>(c) {}
void test() {this->container = 0;}
};
template <class C>
void
test()
{
typedef std::front_insert_iterator<C> R;
C c;
find_container<C> q(c);
q.test();
static_assert((std::is_same<typename R::container_type, C>::value), "");
static_assert((std::is_same<typename R::value_type, void>::value), "");
static_assert((std::is_same<typename R::difference_type, void>::value), "");
static_assert((std::is_same<typename R::reference, R&>::value), "");
static_assert((std::is_same<typename R::pointer, void>::value), "");
static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
}
int main()
{
test<std::vector<int> >();
}

29
test/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp Normal file
View File

@@ -0,0 +1,29 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// insert_iterator
// insert_iterator(Cont& x, Cont::iterator i);
#include <iterator>
#include <vector>
template <class C>
void
test(C c)
{
std::insert_iterator<C> i(c, c.begin());
}
int main()
{
test(std::vector<int>());
}

34
test/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp Normal file
View File

@@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// insert_iterator
// insert_iterator<Cont> operator++(int);
#include <iterator>
#include <vector>
#include <cassert>
template <class C>
void
test(C c)
{
std::insert_iterator<C> i(c, c.end());
std::insert_iterator<C> r = i++;
r = 0;
assert(c.size() == 1);
assert(c.back() == 0);
}
int main()
{
test(std::vector<int>());
}

32
test/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp Normal file
View File

@@ -0,0 +1,32 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// insert_iterator
// insert_iterator<Cont>& operator++();
#include <iterator>
#include <vector>
#include <cassert>
template <class C>
void
test(C c)
{
std::insert_iterator<C> i(c, c.end());
std::insert_iterator<C>& r = ++i;
assert(&r == &i);
}
int main()
{
test(std::vector<int>());
}

64
test/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp Normal file
View File

@@ -0,0 +1,64 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// insert_iterator
// requires CopyConstructible<Cont::value_type>
// insert_iterator<Cont>&
// operator=(const Cont::value_type& value);
#include <iterator>
#include <vector>
#include <cassert>
template <class C>
void
test(C c1, typename C::difference_type j,
typename C::value_type x1, typename C::value_type x2,
typename C::value_type x3, const C& c2)
{
std::insert_iterator<C> q(c1, c1.begin() + j);
q = x1;
q = x2;
q = x3;
assert(c1 == c2);
}
template <class C>
void
insert3at(C& c, typename C::iterator i,
typename C::value_type x1, typename C::value_type x2,
typename C::value_type x3)
{
i = c.insert(i, x1);
i = c.insert(++i, x2);
c.insert(++i, x3);
}
int main()
{
typedef std::vector<int> C;
C c1;
for (int i = 0; i < 3; ++i)
c1.push_back(i);
C c2 = c1;
insert3at(c2, c2.begin(), 'a', 'b', 'c');
test(c1, 0, 'a', 'b', 'c', c2);
c2 = c1;
insert3at(c2, c2.begin()+1, 'a', 'b', 'c');
test(c1, 1, 'a', 'b', 'c', c2);
c2 = c1;
insert3at(c2, c2.begin()+2, 'a', 'b', 'c');
test(c1, 2, 'a', 'b', 'c', c2);
c2 = c1;
insert3at(c2, c2.begin()+3, 'a', 'b', 'c');
test(c1, 3, 'a', 'b', 'c', c2);
}

95
test/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp Normal file
View File

@@ -0,0 +1,95 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// insert_iterator
// requires CopyConstructible<Cont::value_type>
// insert_iterator<Cont>&
// operator=(const Cont::value_type& value);
#include <iterator>
#ifdef _LIBCPP_MOVE
#include <vector>
#include <memory>
#include <cassert>
template <class C>
void
test(C c1, typename C::difference_type j,
typename C::value_type x1, typename C::value_type x2,
typename C::value_type x3, const C& c2)
{
std::insert_iterator<C> q(c1, c1.begin() + j);
q = std::move(x1);
q = std::move(x2);
q = std::move(x3);
assert(c1 == c2);
}
template <class C>
void
insert3at(C& c, typename C::iterator i,
typename C::value_type x1, typename C::value_type x2,
typename C::value_type x3)
{
i = c.insert(i, std::move(x1));
i = c.insert(++i, std::move(x2));
c.insert(++i, std::move(x3));
}
struct do_nothing
{
void operator()(void*) const {}
};
#endif
int main()
{
#ifdef _LIBCPP_MOVE
typedef std::unique_ptr<int, do_nothing> Ptr;
typedef std::vector<Ptr> C;
C c1;
int x[6] = {0};
for (int i = 0; i < 3; ++i)
c1.push_back(Ptr(x+i));
C c2;
for (int i = 0; i < 3; ++i)
c2.push_back(Ptr(x+i));
insert3at(c2, c2.begin(), Ptr(x+3), Ptr(x+4), Ptr(x+5));
test(std::move(c1), 0, Ptr(x+3), Ptr(x+4), Ptr(x+5), c2);
c1.clear();
for (int i = 0; i < 3; ++i)
c1.push_back(Ptr(x+i));
c2.clear();
for (int i = 0; i < 3; ++i)
c2.push_back(Ptr(x+i));
insert3at(c2, c2.begin()+1, Ptr(x+3), Ptr(x+4), Ptr(x+5));
test(std::move(c1), 1, Ptr(x+3), Ptr(x+4), Ptr(x+5), c2);
c1.clear();
for (int i = 0; i < 3; ++i)
c1.push_back(Ptr(x+i));
c2.clear();
for (int i = 0; i < 3; ++i)
c2.push_back(Ptr(x+i));
insert3at(c2, c2.begin()+2, Ptr(x+3), Ptr(x+4), Ptr(x+5));
test(std::move(c1), 2, Ptr(x+3), Ptr(x+4), Ptr(x+5), c2);
c1.clear();
for (int i = 0; i < 3; ++i)
c1.push_back(Ptr(x+i));
c2.clear();
for (int i = 0; i < 3; ++i)
c2.push_back(Ptr(x+i));
insert3at(c2, c2.begin()+3, Ptr(x+3), Ptr(x+4), Ptr(x+5));
test(std::move(c1), 3, Ptr(x+3), Ptr(x+4), Ptr(x+5), c2);
#endif
}

32
test/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp Normal file
View File

@@ -0,0 +1,32 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// insert_iterator
// insert_iterator<Cont>& operator*();
#include <iterator>
#include <vector>
#include <cassert>
template <class C>
void
test(C c)
{
std::insert_iterator<C> i(c, c.end());
std::insert_iterator<C>& r = *i;
assert(&r == &i);
}
int main()
{
test(std::vector<int>());
}

33
test/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp Normal file
View File

@@ -0,0 +1,33 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// template <InsertionContainer Cont>
// insert_iterator<Cont>
// inserter(Cont& x, Cont::iterator i);
#include <iterator>
#include <vector>
#include <cassert>
template <class C>
void
test(C c)
{
std::insert_iterator<C> i = std::inserter(c, c.end());
i = 0;
assert(c.size() == 1);
assert(c.back() == 0);
}
int main()
{
test(std::vector<int>());
}

12
test/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

64
test/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp Normal file
View File

@@ -0,0 +1,64 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// insert_iterator
// Test nested types and data members:
// template <InsertionContainer Cont>
// class insert_iterator {
// protected:
// Cont* container;
// Cont::iterator iter;
// public:
// typedef Cont container_type;
// typedef void value_type;
// typedef void difference_type;
// typedef insert_iterator<Cont>& reference;
// typedef void pointer;
// };
#include <iterator>
#include <type_traits>
#include <vector>
template <class C>
struct find_members
: private std::insert_iterator<C>
{
explicit find_members(C& c) : std::insert_iterator<C>(c, c.begin()) {}
void test()
{
this->container = 0;
this->iter == this->iter;
}
};
template <class C>
void
test()
{
typedef std::insert_iterator<C> R;
C c;
find_members<C> q(c);
q.test();
static_assert((std::is_same<typename R::container_type, C>::value), "");
static_assert((std::is_same<typename R::value_type, void>::value), "");
static_assert((std::is_same<typename R::difference_type, void>::value), "");
static_assert((std::is_same<typename R::reference, R&>::value), "");
static_assert((std::is_same<typename R::pointer, void>::value), "");
static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
}
int main()
{
test<std::vector<int> >();
}

12
test/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

39
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp Normal file
View File

@@ -0,0 +1,39 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <InputIterator Iter>
// move_iterator<Iter>
// make_move_iterator(const Iter& i);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i)
{
const std::move_iterator<It> r(i);
assert(std::make_move_iterator(i) == r);
}
int main()
{
char s[] = "1234567890";
test(input_iterator<char*>(s+5));
test(forward_iterator<char*>(s+5));
test(bidirectional_iterator<char*>(s+5));
test(random_access_iterator<char*>(s+5));
test(s+5);
}

39
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp Normal file
View File

@@ -0,0 +1,39 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <RandomAccessIterator Iter1, RandomAccessIterator Iter2>
// requires HasMinus<Iter1, Iter2>
// auto
// operator-(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y)
// -> decltype(x.base() - y.base());
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It l, It r, typename std::iterator_traits<It>::difference_type x)
{
const std::move_iterator<It> r1(l);
const std::move_iterator<It> r2(r);
assert(r1 - r2 == x);
}
int main()
{
char s[] = "1234567890";
test(random_access_iterator<char*>(s+5), random_access_iterator<char*>(s), 5);
test(s+5, s, 5);
}

37
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp Normal file
View File

@@ -0,0 +1,37 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <RandomAccessIterator Iter>
// move_iterator<Iter>
// operator+(Iter::difference_type n, const move_iterator<Iter>& x);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
const std::move_iterator<It> r(i);
std::move_iterator<It> rr = n + r;
assert(rr.base() == x);
}
int main()
{
char s[] = "1234567890";
test(random_access_iterator<char*>(s+5), 5, random_access_iterator<char*>(s+10));
test(s+5, 5, s+10);
}

36
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp Normal file
View File

@@ -0,0 +1,36 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// requires RandomAccessIterator<Iter>
// move_iterator operator+(difference_type n) const;
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
const std::move_iterator<It> r(i);
std::move_iterator<It> rr = r + n;
assert(rr.base() == x);
}
int main()
{
const char* s = "1234567890";
test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
test(s+5, 5, s+10);
}

37
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp Normal file
View File

@@ -0,0 +1,37 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// requires RandomAccessIterator<Iter>
// move_iterator& operator+=(difference_type n);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
std::move_iterator<It> r(i);
std::move_iterator<It>& rr = r += n;
assert(r.base() == x);
assert(&rr == &r);
}
int main()
{
const char* s = "1234567890";
test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
test(s+5, 5, s+10);
}

36
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp Normal file
View File

@@ -0,0 +1,36 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// requires RandomAccessIterator<Iter>
// move_iterator operator-(difference_type n) const;
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
const std::move_iterator<It> r(i);
std::move_iterator<It> rr = r - n;
assert(rr.base() == x);
}
int main()
{
const char* s = "1234567890";
test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
test(s+5, 5, s);
}

37
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp Normal file
View File

@@ -0,0 +1,37 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// requires RandomAccessIterator<Iter>
// move_iterator& operator-=(difference_type n);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
std::move_iterator<It> r(i);
std::move_iterator<It>& rr = r -= n;
assert(r.base() == x);
assert(&rr == &r);
}
int main()
{
const char* s = "1234567890";
test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
test(s+5, 5, s);
}

46
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp Normal file
View File

@@ -0,0 +1,46 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <InputIterator Iter1, InputIterator Iter2>
// requires HasEqualTo<Iter1, Iter2>
// bool
// operator==(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It l, It r, bool x)
{
const std::move_iterator<It> r1(l);
const std::move_iterator<It> r2(r);
assert((r1 == r2) == x);
}
int main()
{
char s[] = "1234567890";
test(input_iterator<char*>(s), input_iterator<char*>(s), true);
test(input_iterator<char*>(s), input_iterator<char*>(s+1), false);
test(forward_iterator<char*>(s), forward_iterator<char*>(s), true);
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1), false);
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s), true);
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1), false);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), false);
test(s, s, true);
test(s, s+1, false);
}

42
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp Normal file
View File

@@ -0,0 +1,42 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <RandomAccessIterator Iter1, RandomAccessIterator Iter2>
// requires HasLess<Iter2, Iter1>
// bool
// operator>(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It l, It r, bool x)
{
const std::move_iterator<It> r1(l);
const std::move_iterator<It> r2(r);
assert((r1 > r2) == x);
}
int main()
{
char s[] = "1234567890";
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), false);
test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s), true);
test(s, s, false);
test(s, s+1, false);
test(s+1, s, true);
}

42
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp Normal file
View File

@@ -0,0 +1,42 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <RandomAccessIterator Iter1, RandomAccessIterator Iter2>
// requires HasLess<Iter1, Iter2>
// bool
// operator>=(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It l, It r, bool x)
{
const std::move_iterator<It> r1(l);
const std::move_iterator<It> r2(r);
assert((r1 >= r2) == x);
}
int main()
{
char s[] = "1234567890";
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), false);
test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s), true);
test(s, s, true);
test(s, s+1, false);
test(s+1, s, true);
}

42
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp Normal file
View File

@@ -0,0 +1,42 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <RandomAccessIterator Iter1, RandomAccessIterator Iter2>
// requires HasLess<Iter1, Iter2>
// bool
// operator<(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It l, It r, bool x)
{
const std::move_iterator<It> r1(l);
const std::move_iterator<It> r2(r);
assert((r1 < r2) == x);
}
int main()
{
char s[] = "1234567890";
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), true);
test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s), false);
test(s, s, false);
test(s, s+1, true);
test(s+1, s, false);
}

42
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp Normal file
View File

@@ -0,0 +1,42 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <RandomAccessIterator Iter1, RandomAccessIterator Iter2>
// requires HasLess<Iter2, Iter1>
// bool
// operator<=(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It l, It r, bool x)
{
const std::move_iterator<It> r1(l);
const std::move_iterator<It> r2(r);
assert((r1 <= r2) == x);
}
int main()
{
char s[] = "1234567890";
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), true);
test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s), false);
test(s, s, true);
test(s, s+1, true);
test(s+1, s, false);
}

46
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp Normal file
View File

@@ -0,0 +1,46 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <InputIterator Iter1, InputIterator Iter2>
// requires HasEqualTo<Iter1, Iter2>
// bool
// operator!=(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It l, It r, bool x)
{
const std::move_iterator<It> r1(l);
const std::move_iterator<It> r2(r);
assert((r1 != r2) == x);
}
int main()
{
char s[] = "1234567890";
test(input_iterator<char*>(s), input_iterator<char*>(s), false);
test(input_iterator<char*>(s), input_iterator<char*>(s+1), true);
test(forward_iterator<char*>(s), forward_iterator<char*>(s), false);
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1), true);
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s), false);
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1), true);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), true);
test(s, s, false);
test(s, s+1, true);
}

38
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp Normal file
View File

@@ -0,0 +1,38 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <class U>
// requires HasConstructor<Iter, const U&>
// move_iterator(const move_iterator<U> &u);
// test requires
#include <iterator>
template <class It, class U>
void
test(U u)
{
std::move_iterator<U> r2(u);
std::move_iterator<It> r1 = r2;
}
struct base {};
struct derived {};
int main()
{
derived d;
test<base*>(&d);
}

44
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp Normal file
View File

@@ -0,0 +1,44 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <class U>
// requires HasConstructor<Iter, const U&>
// move_iterator(const move_iterator<U> &u);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It, class U>
void
test(U u)
{
const std::move_iterator<U> r2(u);
std::move_iterator<It> r1 = r2;
assert(r1.base() == u);
}
struct base {};
struct derived : base {};
int main()
{
derived d;
test<input_iterator<base*> >(input_iterator<derived*>(&d));
test<forward_iterator<base*> >(forward_iterator<derived*>(&d));
test<bidirectional_iterator<base*> >(bidirectional_iterator<derived*>(&d));
test<random_access_iterator<const base*> >(random_access_iterator<derived*>(&d));
test<base*>(&d);
}

34
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp Normal file
View File

@@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// move_iterator();
#include <iterator>
#include "../../../../iterators.h"
template <class It>
void
test()
{
std::move_iterator<It> r;
}
int main()
{
test<input_iterator<char*> >();
test<forward_iterator<char*> >();
test<bidirectional_iterator<char*> >();
test<random_access_iterator<char*> >();
test<char*>();
}

31
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp Normal file
View File

@@ -0,0 +1,31 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// explicit move_iterator(Iter );
// test explicit
#include <iterator>
template <class It>
void
test(It i)
{
std::move_iterator<It> r = i;
}
int main()
{
char s[] = "123";
test(s);
}

37
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp Normal file
View File

@@ -0,0 +1,37 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// explicit move_iterator(Iter i);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i)
{
std::move_iterator<It> r(i);
assert(r.base() == i);
}
int main()
{
char s[] = "123";
test(input_iterator<char*>(s));
test(forward_iterator<char*>(s));
test(bidirectional_iterator<char*>(s));
test(random_access_iterator<char*>(s));
test(s);
}

12
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

37
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp Normal file
View File

@@ -0,0 +1,37 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// move_iterator operator--(int);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i, It x)
{
std::move_iterator<It> r(i);
std::move_iterator<It> rr = r--;
assert(r.base() == x);
assert(rr.base() == i);
}
int main()
{
char s[] = "123";
test(bidirectional_iterator<char*>(s+1), bidirectional_iterator<char*>(s));
test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s));
test(s+1, s);
}

37
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp Normal file
View File

@@ -0,0 +1,37 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// move_iterator& operator--();
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i, It x)
{
std::move_iterator<It> r(i);
std::move_iterator<It>& rr = --r;
assert(r.base() == x);
assert(&rr == &r);
}
int main()
{
char s[] = "123";
test(bidirectional_iterator<char*>(s+1), bidirectional_iterator<char*>(s));
test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s));
test(s+1, s);
}

39
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp Normal file
View File

@@ -0,0 +1,39 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// move_iterator operator++(int);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i, It x)
{
std::move_iterator<It> r(i);
std::move_iterator<It> rr = r++;
assert(r.base() == x);
assert(rr.base() == i);
}
int main()
{
char s[] = "123";
test(input_iterator<char*>(s), input_iterator<char*>(s+1));
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1));
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1));
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1));
test(s, s+1);
}

39
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp Normal file
View File

@@ -0,0 +1,39 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// move_iterator& operator++();
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i, It x)
{
std::move_iterator<It> r(i);
std::move_iterator<It>& rr = ++r;
assert(r.base() == x);
assert(&rr == &r);
}
int main()
{
char s[] = "123";
test(input_iterator<char*>(s), input_iterator<char*>(s+1));
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1));
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1));
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1));
test(s, s+1);
}

58
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp Normal file
View File

@@ -0,0 +1,58 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// requires RandomAccessIterator<Iter>
// unspecified operator[](difference_type n) const;
#include <iterator>
#include <cassert>
#ifdef _LIBCPP_MOVE
#include <memory>
#endif
#include "../../../../iterators.h"
template <class It>
void
test(It i, typename std::iterator_traits<It>::difference_type n,
typename std::iterator_traits<It>::value_type x)
{
typedef typename std::iterator_traits<It>::value_type value_type;
const std::move_iterator<It> r(i);
value_type rr = r[n];
assert(rr == x);
}
#ifdef _LIBCPP_MOVE
struct do_nothing
{
void operator()(void*) const {}
};
#endif
int main()
{
char s[] = "1234567890";
test(random_access_iterator<char*>(s+5), 4, '0');
test(s+5, 4, '0');
#ifdef _LIBCPP_MOVE
int i[5];
typedef std::unique_ptr<int, do_nothing> Ptr;
Ptr p[5];
for (unsigned j = 0; j < 5; ++j)
p[j].reset(i+j);
test(p, 3, Ptr(i+3));
#endif
}

31
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp Normal file
View File

@@ -0,0 +1,31 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// pointer operator->() const;
#include <iterator>
#include <cassert>
template <class It>
void
test(It i)
{
std::move_iterator<It> r(i);
assert(r.operator->() == i);
}
int main()
{
char s[] = "123";
test(s);
}

61
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp Normal file
View File

@@ -0,0 +1,61 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// reference operator*() const;
#include <iterator>
#include <cassert>
#ifdef _LIBCPP_MOVE
#include <memory>
#endif
class A
{
int data_;
public:
A() : data_(1) {}
~A() {data_ = -1;}
friend bool operator==(const A& x, const A& y)
{return x.data_ == y.data_;}
};
template <class It>
void
test(It i, typename std::iterator_traits<It>::value_type x)
{
std::move_iterator<It> r(i);
assert(*r == x);
typename std::iterator_traits<It>::value_type x2 = *r;
assert(x2 == x);
}
#ifdef _LIBCPP_MOVE
struct do_nothing
{
void operator()(void*) const {}
};
#endif
int main()
{
A a;
test(&a, A());
#ifdef _LIBCPP_MOVE
int i;
std::unique_ptr<int, do_nothing> p(&i);
test(&p, std::unique_ptr<int, do_nothing>(&i));
#endif
}

39
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp Normal file
View File

@@ -0,0 +1,39 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <class U>
// requires HasAssign<Iter, const U&>
// move_iterator&
// operator=(const move_iterator<U>& u);
// test requires
#include <iterator>
template <class It, class U>
void
test(U u)
{
const std::move_iterator<U> r2(u);
std::move_iterator<It> r1;
r1 = r2;
}
struct base {};
struct derived {};
int main()
{
derived d;
test<base*>(&d);
}

47
test/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp Normal file
View File

@@ -0,0 +1,47 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// template <class U>
// requires HasAssign<Iter, const U&>
// move_iterator&
// operator=(const move_iterator<U>& u);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It, class U>
void
test(U u)
{
const std::move_iterator<U> r2(u);
std::move_iterator<It> r1;
std::move_iterator<It>& rr = r1 = r2;
assert(r1.base() == u);
assert(&rr == &r1);
}
struct base {};
struct derived : base {};
int main()
{
derived d;
test<input_iterator<base*> >(input_iterator<derived*>(&d));
test<forward_iterator<base*> >(forward_iterator<derived*>(&d));
test<bidirectional_iterator<base*> >(bidirectional_iterator<derived*>(&d));
test<random_access_iterator<const base*> >(random_access_iterator<derived*>(&d));
test<base*>(&d);
}

12
test/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

56
test/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp Normal file
View File

@@ -0,0 +1,56 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// move_iterator
// Test nested types:
// template <InputIterator Iter>
// class move_iterator {
// public:
// typedef Iter iterator_type;
// typedef Iter::difference_type difference_type;
// typedef Iterator pointer;
// typedef Iter::value_type value_type;
// typedef value_type&& reference;
// };
#include <iterator>
#include <type_traits>
#include "../../../iterators.h"
template <class It>
void
test()
{
typedef std::move_iterator<It> R;
typedef std::iterator_traits<It> T;
static_assert((std::is_same<typename R::iterator_type, It>::value), "");
static_assert((std::is_same<typename R::difference_type, typename T::difference_type>::value), "");
static_assert((std::is_same<typename R::pointer, typename T::pointer>::value), "");
static_assert((std::is_same<typename R::value_type, typename T::value_type>::value), "");
#ifdef _LIBCPP_MOVE
static_assert((std::is_same<typename R::reference, typename R::value_type&&>::value), "");
#else
static_assert((std::is_same<typename R::reference, typename T::reference>::value), "");
#endif
static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
}
int main()
{
test<input_iterator<char*> >();
test<forward_iterator<char*> >();
test<bidirectional_iterator<char*> >();
test<random_access_iterator<char*> >();
test<char*>();
}

12
test/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/predef.iterators/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

12
test/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

33
test/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp Normal file
View File

@@ -0,0 +1,33 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// reverse_iterator
// reverse_iterator();
#include <iterator>
#include "../../../../iterators.h"
template <class It>
void
test()
{
std::reverse_iterator<It> r;
}
int main()
{
test<bidirectional_iterator<const char*> >();
test<random_access_iterator<char*> >();
test<char*>();
test<const char*>();
}

31
test/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp Normal file
View File

@@ -0,0 +1,31 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// reverse_iterator
// explicit reverse_iterator(Iter x);
// test explicit
#include <iterator>
template <class It>
void
test(It i)
{
std::reverse_iterator<It> r = i;
}
int main()
{
const char s[] = "123";
test(s);
}

35
test/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp Normal file
View File

@@ -0,0 +1,35 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// reverse_iterator
// explicit reverse_iterator(Iter x);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i)
{
std::reverse_iterator<It> r(i);
assert(r.base() == i);
}
int main()
{
const char s[] = "123";
test(bidirectional_iterator<const char*>(s));
test(random_access_iterator<const char*>(s));
test(s);
}

38
test/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp Normal file
View File

@@ -0,0 +1,38 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// reverse_iterator
// template <class U>
// requires HasConstructor<Iter, const U&>
// reverse_iterator(const reverse_iterator<U> &u);
// test requires
#include <iterator>
template <class It, class U>
void
test(U u)
{
std::reverse_iterator<U> r2(u);
std::reverse_iterator<It> r1 = r2;
}
struct base {};
struct derived {};
int main()
{
derived d;
test<base*>(&d);
}

42
test/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp Normal file
View File

@@ -0,0 +1,42 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// reverse_iterator
// template <class U>
// requires HasConstructor<Iter, const U&>
// reverse_iterator(const reverse_iterator<U> &u);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It, class U>
void
test(U u)
{
const std::reverse_iterator<U> r2(u);
std::reverse_iterator<It> r1 = r2;
assert(r1.base() == u);
}
struct base {};
struct derived : base {};
int main()
{
derived d;
test<bidirectional_iterator<base*> >(bidirectional_iterator<derived*>(&d));
test<random_access_iterator<const base*> >(random_access_iterator<derived*>(&d));
test<base*>(&d);
}

12
test/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp Normal file
View File

@@ -0,0 +1,12 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

42
test/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp Normal file
View File

@@ -0,0 +1,42 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// reverse_iterator
// template <BidirectionalIterator Iter1, BidirectionalIterator Iter2>
// requires HasEqualTo<Iter1, Iter2>
// bool
// operator!=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It l, It r, bool x)
{
const std::reverse_iterator<It> r1(l);
const std::reverse_iterator<It> r2(r);
assert((r1 != r2) == x);
}
int main()
{
const char* s = "1234567890";
test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s), false);
test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+1), true);
test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), false);
test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1), true);
test(s, s, false);
test(s, s+1, true);
}

37
test/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp Normal file
View File

@@ -0,0 +1,37 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// reverse_iterator
// reverse_iterator operator++(int);
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i, It x)
{
std::reverse_iterator<It> r(i);
std::reverse_iterator<It> rr = r++;
assert(r.base() == x);
assert(rr.base() == i);
}
int main()
{
const char* s = "123";
test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s));
test(s+1, s);
}

37
test/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp Normal file
View File

@@ -0,0 +1,37 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <iterator>
// reverse_iterator
// reverse_iterator& operator++();
#include <iterator>
#include <cassert>
#include "../../../../iterators.h"
template <class It>
void
test(It i, It x)
{
std::reverse_iterator<It> r(i);
std::reverse_iterator<It>& rr = ++r;
assert(r.base() == x);
assert(&rr == &r);
}
int main()
{
const char* s = "123";
test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s));
test(s+1, s);
}

Some files were not shown because too many files have changed in this diff Show More