test/std/containers/views/span.comparison/op.eq.pass.cpp

   1 // -*- C++ -*-
   2 //===------------------------------ span ---------------------------------===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is dual licensed under the MIT and the University of Illinois Open
   7 // Source Licenses. See LICENSE.TXT for details.
   8 //
   9 //===---------------------------------------------------------------------===//
  10 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
  11
  12 // <span>
  13
  14 // template<class T, ptrdiff_t X, class U, ptrdiff_t Y>
  15 //   constexpr bool operator==(span<T, X> l, span<U, Y> r);
  16 //
  17 //
  18 // Effects: Equivalent to: return equal(l.begin(), l.end(), r.begin(), r.end());
  19 //
  20
  21 #include <span>
  22 #include <cassert>
  23
  24 #include "test_macros.h"
  25
  26 struct A{};
  27 bool operator==(A, A) {return true;}
  28
  29 constexpr   int iArr1[] = { 0,  1,  2,  1,  2,  5,  6,  7,  8,  9};
  30             int iArr2[] = { 0,  1,  2,  1,  2,  5,  6,  7,  8,  9};
  31 constexpr float fArr1[]  = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
  32           float fArr2[]  = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
  33
  34
  35 int main () {
  36
  37     constexpr std::span<const int>     csp0d{};
  38     constexpr std::span<const int>     csp1d{iArr1, 10};
  39     constexpr std::span<const int>     csp2d{iArr1 + 3, 2};
  40     constexpr std::span<const int>     csp3d{iArr1 + 1, 2};
  41     constexpr std::span<const int>     csp4d{iArr1 + 6, 2};
  42
  43     constexpr std::span<const int,  0> csp0s{};
  44     constexpr std::span<const int, 10> csp1s{iArr1, 10};
  45     constexpr std::span<const int, 2>  csp2s{iArr1 + 3, 2};
  46     constexpr std::span<const int, 2>  csp3s{iArr1 + 1, 2};
  47     constexpr std::span<const int, 2>  csp4s{iArr1 + 6, 2};
  48
  49     static_assert( (csp0d == csp0d), "");
  50     static_assert( (csp0s == csp0s), "");
  51     static_assert( (csp0s == csp0d), "");
  52     static_assert( (csp0d == csp0s), "");
  53
  54     static_assert(!(csp0d == csp1d), "");
  55     static_assert(!(csp0s == csp1s), "");
  56     static_assert(!(csp0s == csp1d), "");
  57     static_assert(!(csp0d == csp1s), "");
  58
  59     static_assert( (csp1d == csp1s), "");
  60     static_assert( (csp1s == csp1d), "");
  61
  62     static_assert( (csp2d == csp3d), "");
  63     static_assert( (csp2s == csp3s), "");
  64     static_assert( (csp2d == csp3s), "");
  65     static_assert( (csp2s == csp3d), "");
  66
  67     static_assert( (csp2d == csp3d), "");
  68     static_assert( (csp2s == csp3s), "");
  69     static_assert( (csp2d == csp3s), "");
  70     static_assert( (csp2s == csp3d), "");
  71
  72     static_assert(!(csp2d == csp4d), "");
  73     static_assert(!(csp2s == csp4s), "");
  74     static_assert(!(csp2d == csp4s), "");
  75     static_assert(!(csp2s == csp4d), "");
  76
  77     static_assert(!(csp4d == csp2d), "");
  78     static_assert(!(csp4s == csp2s), "");
  79     static_assert(!(csp4d == csp2s), "");
  80     static_assert(!(csp4s == csp2d), "");
  81
  82     std::span<int>     sp0d{};
  83     std::span<int>     sp1d{iArr2, 10};
  84     std::span<int>     sp2d{iArr2 + 3, 2};
  85     std::span<int>     sp3d{iArr2 + 1, 2};
  86     std::span<int>     sp4d{iArr2 + 6, 2};
  87
  88     std::span<int,  0> sp0s{};
  89     std::span<int, 10> sp1s{iArr2, 10};
  90     std::span<int, 2>  sp2s{iArr2 + 3, 2};
  91     std::span<int, 2>  sp3s{iArr2 + 1, 2};
  92     std::span<int, 2>  sp4s{iArr2 + 6, 2};
  93
  94     assert( (sp0d == sp0d));
  95     assert( (sp0s == sp0s));
  96     assert( (sp0s == sp0d));
  97     assert( (sp0d == sp0s));
  98
  99     assert(!(sp0d == sp1d));
 100     assert(!(sp0s == sp1s));
 101     assert(!(sp0s == sp1d));
 102     assert(!(sp0d == sp1s));
 103
 104     assert( (sp1d == sp1s));
 105     assert( (sp1s == sp1d));
 106
 107     assert( (sp2d == sp3d));
 108     assert( (sp2s == sp3s));
 109     assert( (sp2d == sp3s));
 110     assert( (sp2s == sp3d));
 111
 112     assert( (sp2d == sp3d));
 113     assert( (sp2s == sp3s));
 114     assert( (sp2d == sp3s));
 115     assert( (sp2s == sp3d));
 116
 117     assert(!(sp2d == sp4d));
 118     assert(!(sp2s == sp4s));
 119     assert(!(sp2d == sp4s));
 120     assert(!(sp2s == sp4d));
 121
 122     assert(!(sp4d == sp2d));
 123     assert(!(sp4s == sp2s));
 124     assert(!(sp4d == sp2s));
 125     assert(!(sp4s == sp2d));
 126
 127 //  cross type comparisons
 128     assert( (csp0d == sp0d));
 129     assert( (csp0s == sp0s));
 130     assert( (csp0s == sp0d));
 131     assert( (csp0d == sp0s));
 132
 133     assert(!(csp0d == sp1d));
 134     assert(!(csp0s == sp1s));
 135     assert(!(csp0s == sp1d));
 136     assert(!(csp0d == sp1s));
 137
 138     assert( (csp1d == sp1s));
 139     assert( (csp1s == sp1d));
 140
 141     assert( (csp2d == sp3d));
 142     assert( (csp2s == sp3s));
 143     assert( (csp2d == sp3s));
 144     assert( (csp2s == sp3d));
 145
 146     assert( (csp2d == sp3d));
 147     assert( (csp2s == sp3s));
 148     assert( (csp2d == sp3s));
 149     assert( (csp2s == sp3d));
 150
 151     assert(!(csp2d == sp4d));
 152     assert(!(csp2s == sp4s));
 153     assert(!(csp2d == sp4s));
 154     assert(!(csp2s == sp4d));
 155
 156     assert(!(csp4d == sp2d));
 157     assert(!(csp4s == sp2s));
 158     assert(!(csp4d == sp2s));
 159     assert(!(csp4s == sp2d));
 160
 161 //  More cross-type comparisons (int vs float)
 162     static_assert(std::span<const float>{fArr1} == std::span<const   int>{iArr1}, "");
 163     static_assert(std::span<const   int>{iArr1} == std::span<const float>{fArr1}, "");
 164     assert(std::span<float>{fArr2} == std::span<int>{iArr2});
 165     assert(std::span<int>{iArr2} == std::span<float>{fArr2});
 166
 167     static_assert(!(std::span<const   int>{iArr1, 9} == std::span<const float>{fArr1, 8}), "");
 168 }