test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // <numeric>
  11
  12 // template <InputIterator InIter,
  13 //           OutputIterator<auto, const InIter::value_type&> OutIter>
  14 //   requires HasMinus<InIter::value_type, InIter::value_type>
  15 //         && Constructible<InIter::value_type, InIter::reference>
  16 //         && OutputIterator<OutIter,
  17 //                           HasMinus<InIter::value_type, InIter::value_type>::result_type>
  18 //         && MoveAssignable<InIter::value_type>
  19 //   OutIter
  20 //   adjacent_difference(InIter first, InIter last, OutIter result);
  21
  22 #include <numeric>
  23 #include <cassert>
  24
  25 #include "test_macros.h"
  26 #include "test_iterators.h"
  27
  28 template <class InIter, class OutIter>
  29 void
  30 test()
  31 {
  32     int ia[] = {15, 10, 6, 3, 1};
  33     int ir[] = {15, -5, -4, -3, -2};
  34     const unsigned s = sizeof(ia) / sizeof(ia[0]);
  35     int ib[s] = {0};
  36     OutIter r = std::adjacent_difference(InIter(ia), InIter(ia+s), OutIter(ib));
  37     assert(base(r) == ib + s);
  38     for (unsigned i = 0; i < s; ++i)
  39         assert(ib[i] == ir[i]);
  40 }
  41
  42 #if TEST_STD_VER >= 11
  43
  44 class Y;
  45
  46 class X
  47 {
  48     int i_;
  49
  50     X& operator=(const X&);
  51 public:
  52     explicit X(int i) : i_(i) {}
  53     X(const X& x) : i_(x.i_) {}
  54     X& operator=(X&& x)
  55     {
  56         i_ = x.i_;
  57         x.i_ = -1;
  58         return *this;
  59     }
  60
  61     friend X operator-(const X& x, const X& y) {return X(x.i_ - y.i_);}
  62
  63     friend class Y;
  64 };
  65
  66 class Y
  67 {
  68     int i_;
  69
  70     Y& operator=(const Y&);
  71 public:
  72     explicit Y(int i) : i_(i) {}
  73     Y(const Y& y) : i_(y.i_) {}
  74     void operator=(const X& x) {i_ = x.i_;}
  75 };
  76
  77 #endif
  78
  79 int main()
  80 {
  81     test<input_iterator<const int*>, output_iterator<int*> >();
  82     test<input_iterator<const int*>, forward_iterator<int*> >();
  83     test<input_iterator<const int*>, bidirectional_iterator<int*> >();
  84     test<input_iterator<const int*>, random_access_iterator<int*> >();
  85     test<input_iterator<const int*>, int*>();
  86
  87     test<forward_iterator<const int*>, output_iterator<int*> >();
  88     test<forward_iterator<const int*>, forward_iterator<int*> >();
  89     test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
  90     test<forward_iterator<const int*>, random_access_iterator<int*> >();
  91     test<forward_iterator<const int*>, int*>();
  92
  93     test<bidirectional_iterator<const int*>, output_iterator<int*> >();
  94     test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
  95     test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
  96     test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
  97     test<bidirectional_iterator<const int*>, int*>();
  98
  99     test<random_access_iterator<const int*>, output_iterator<int*> >();
 100     test<random_access_iterator<const int*>, forward_iterator<int*> >();
 101     test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
 102     test<random_access_iterator<const int*>, random_access_iterator<int*> >();
 103     test<random_access_iterator<const int*>, int*>();
 104
 105     test<const int*, output_iterator<int*> >();
 106     test<const int*, forward_iterator<int*> >();
 107     test<const int*, bidirectional_iterator<int*> >();
 108     test<const int*, random_access_iterator<int*> >();
 109     test<const int*, int*>();
 110
 111 #if TEST_STD_VER >= 11
 112     X x[3] = {X(1), X(2), X(3)};
 113     Y y[3] = {Y(1), Y(2), Y(3)};
 114     std::adjacent_difference(x, x+3, y);
 115 #endif
 116 }