2 //===------------------------------ span ---------------------------------===//
4 // The LLVM Compiler Infrastructure
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
9 //===---------------------------------------------------------------------===//
10 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
14 // template<class T, ptrdiff_t X, class U, ptrdiff_t Y>
15 // constexpr bool operator!=(span<T, X> l, span<U, Y> r);
18 // Effects: Equivalent to: return !(l == r);
24 #include "test_macros.h"
27 bool operator==(A, A) {return true;}
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.};
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};
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};
49 static_assert(!(csp0d != csp0d), "");
50 static_assert(!(csp0s != csp0s), "");
51 static_assert(!(csp0s != csp0d), "");
52 static_assert(!(csp0d != csp0s), "");
54 static_assert( (csp0d != csp1d), "");
55 static_assert( (csp0s != csp1s), "");
56 static_assert( (csp0s != csp1d), "");
57 static_assert( (csp0d != csp1s), "");
59 static_assert(!(csp1d != csp1s), "");
60 static_assert(!(csp1s != csp1d), "");
62 static_assert(!(csp2d != csp3d), "");
63 static_assert(!(csp2s != csp3s), "");
64 static_assert(!(csp2d != csp3s), "");
65 static_assert(!(csp2s != csp3d), "");
67 static_assert(!(csp2d != csp3d), "");
68 static_assert(!(csp2s != csp3s), "");
69 static_assert(!(csp2d != csp3s), "");
70 static_assert(!(csp2s != csp3d), "");
72 static_assert( (csp2d != csp4d), "");
73 static_assert( (csp2s != csp4s), "");
74 static_assert( (csp2d != csp4s), "");
75 static_assert( (csp2s != csp4d), "");
77 static_assert( (csp4d != csp2d), "");
78 static_assert( (csp4s != csp2s), "");
79 static_assert( (csp4d != csp2s), "");
80 static_assert( (csp4s != csp2d), "");
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};
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};
94 assert(!(sp0d != sp0d));
95 assert(!(sp0s != sp0s));
96 assert(!(sp0s != sp0d));
97 assert(!(sp0d != sp0s));
99 assert( (sp0d != sp1d));
100 assert( (sp0s != sp1s));
101 assert( (sp0s != sp1d));
102 assert( (sp0d != sp1s));
104 assert(!(sp1d != sp1s));
105 assert(!(sp1s != sp1d));
107 assert(!(sp2d != sp3d));
108 assert(!(sp2s != sp3s));
109 assert(!(sp2d != sp3s));
110 assert(!(sp2s != sp3d));
112 assert(!(sp2d != sp3d));
113 assert(!(sp2s != sp3s));
114 assert(!(sp2d != sp3s));
115 assert(!(sp2s != sp3d));
117 assert( (sp2d != sp4d));
118 assert( (sp2s != sp4s));
119 assert( (sp2d != sp4s));
120 assert( (sp2s != sp4d));
122 assert( (sp4d != sp2d));
123 assert( (sp4s != sp2s));
124 assert( (sp4d != sp2s));
125 assert( (sp4s != sp2d));
127 // cross type comparisons
128 assert(!(csp0d != sp0d));
129 assert(!(csp0s != sp0s));
130 assert(!(csp0s != sp0d));
131 assert(!(csp0d != sp0s));
133 assert( (csp0d != sp1d));
134 assert( (csp0s != sp1s));
135 assert( (csp0s != sp1d));
136 assert( (csp0d != sp1s));
138 assert(!(csp1d != sp1s));
139 assert(!(csp1s != sp1d));
141 assert(!(csp2d != sp3d));
142 assert(!(csp2s != sp3s));
143 assert(!(csp2d != sp3s));
144 assert(!(csp2s != sp3d));
146 assert(!(csp2d != sp3d));
147 assert(!(csp2s != sp3s));
148 assert(!(csp2d != sp3s));
149 assert(!(csp2s != sp3d));
151 assert( (csp2d != sp4d));
152 assert( (csp2s != sp4s));
153 assert( (csp2d != sp4s));
154 assert( (csp2s != sp4d));
156 assert( (csp4d != sp2d));
157 assert( (csp4s != sp2s));
158 assert( (csp4d != sp2s));
159 assert( (csp4s != sp2d));
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}));
167 static_assert( (std::span<const int>{iArr1, 9} != std::span<const float>{fArr1, 8}), "");