ceph/src/jaegertracing/opentelemetry-cpp/third_party/ms-gsl/tests/algorithm_tests.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 // Copyright (c) 2015 Microsoft Corporation. All rights reserved.
   4 //
   5 // This code is licensed under the MIT License (MIT).
   6 //
   7 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   8 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   9 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  10 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  11 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  12 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  13 // THE SOFTWARE.
  14 //
  15 ///////////////////////////////////////////////////////////////////////////////
  16
  17 #include <gtest/gtest.h>
  18 #include <gsl/gsl_algorithm> // for copy
  19 #include <gsl/span>          // for span
  20 #include <array>   // for array
  21 #include <cstddef> // for size_t
  22
  23 namespace
  24 {
  25     static constexpr char deathstring[] = "Expected Death";
  26 }
  27
  28 namespace gsl
  29 {
  30 struct fail_fast;
  31 } // namespace gsl
  32
  33 using namespace std;
  34 using namespace gsl;
  35
  36 TEST(algorithm_tests, same_type)
  37 {
  38     // dynamic source and destination span
  39     {
  40         std::array<int, 5> src{1, 2, 3, 4, 5};
  41         std::array<int, 10> dst{};
  42
  43         const span<int> src_span(src);
  44         const span<int> dst_span(dst);
  45
  46         copy(src_span, dst_span);
  47         copy(src_span, dst_span.subspan(src_span.size()));
  48
  49         for (std::size_t i = 0; i < src.size(); ++i)
  50         {
  51             EXPECT_TRUE(dst[i] == src[i]);
  52             EXPECT_TRUE(dst[i + src.size()] == src[i]);
  53         }
  54     }
  55
  56     // static source and dynamic destination span
  57     {
  58         std::array<int, 5> src{1, 2, 3, 4, 5};
  59         std::array<int, 10> dst{};
  60
  61         const span<int, 5> src_span(src);
  62         const span<int> dst_span(dst);
  63
  64         copy(src_span, dst_span);
  65         copy(src_span, dst_span.subspan(src_span.size()));
  66
  67         for (std::size_t i = 0; i < src.size(); ++i)
  68         {
  69             EXPECT_TRUE(dst[i] == src[i]);
  70             EXPECT_TRUE(dst[i + src.size()] == src[i]);
  71         }
  72     }
  73
  74     // dynamic source and static destination span
  75     {
  76         std::array<int, 5> src{1, 2, 3, 4, 5};
  77         std::array<int, 10> dst{};
  78
  79         const span<int> src_span(src);
  80         const span<int, 10> dst_span(dst);
  81
  82         copy(src_span, dst_span);
  83         copy(src_span, dst_span.subspan(src_span.size()));
  84
  85         for (std::size_t i = 0; i < src.size(); ++i)
  86         {
  87             EXPECT_TRUE(dst[i] == src[i]);
  88             EXPECT_TRUE(dst[i + src.size()] == src[i]);
  89         }
  90     }
  91
  92     // static source and destination span
  93     {
  94         std::array<int, 5> src{1, 2, 3, 4, 5};
  95         std::array<int, 10> dst{};
  96
  97         const span<int, 5> src_span(src);
  98         const span<int, 10> dst_span(dst);
  99
 100         copy(src_span, dst_span);
 101         copy(src_span, dst_span.subspan(src_span.size()));
 102
 103         for (std::size_t i = 0; i < src.size(); ++i)
 104         {
 105             EXPECT_TRUE(dst[i] == src[i]);
 106             EXPECT_TRUE(dst[i + src.size()] == src[i]);
 107         }
 108     }
 109 }
 110
 111 TEST(algorithm_tests, compatible_type)
 112 {
 113     // dynamic source and destination span
 114     {
 115         std::array<short, 5> src{1, 2, 3, 4, 5};
 116         std::array<int, 10> dst{};
 117
 118         const span<short> src_span(src);
 119         const span<int> dst_span(dst);
 120
 121         copy(src_span, dst_span);
 122         copy(src_span, dst_span.subspan(src_span.size()));
 123
 124         for (std::size_t i = 0; i < src.size(); ++i)
 125         {
 126             EXPECT_TRUE(dst[i] == src[i]);
 127             EXPECT_TRUE(dst[i + src.size()] == src[i]);
 128         }
 129     }
 130
 131     // static source and dynamic destination span
 132     {
 133         std::array<short, 5> src{1, 2, 3, 4, 5};
 134         std::array<int, 10> dst{};
 135
 136         const span<short, 5> src_span(src);
 137         const span<int> dst_span(dst);
 138
 139         copy(src_span, dst_span);
 140         copy(src_span, dst_span.subspan(src_span.size()));
 141
 142         for (std::size_t i = 0; i < src.size(); ++i)
 143         {
 144             EXPECT_TRUE(dst[i] == src[i]);
 145             EXPECT_TRUE(dst[i + src.size()] == src[i]);
 146         }
 147     }
 148
 149     // dynamic source and static destination span
 150     {
 151         std::array<short, 5> src{1, 2, 3, 4, 5};
 152         std::array<int, 10> dst{};
 153
 154         const span<short> src_span(src);
 155         const span<int, 10> dst_span(dst);
 156
 157         copy(src_span, dst_span);
 158         copy(src_span, dst_span.subspan(src_span.size()));
 159
 160         for (std::size_t i = 0; i < src.size(); ++i)
 161         {
 162             EXPECT_TRUE(dst[i] == src[i]);
 163             EXPECT_TRUE(dst[i + src.size()] == src[i]);
 164         }
 165     }
 166
 167     // static source and destination span
 168     {
 169         std::array<short, 5> src{1, 2, 3, 4, 5};
 170         std::array<int, 10> dst{};
 171
 172         const span<short, 5> src_span(src);
 173         const span<int, 10> dst_span(dst);
 174
 175         copy(src_span, dst_span);
 176         copy(src_span, dst_span.subspan(src_span.size()));
 177
 178         for (std::size_t i = 0; i < src.size(); ++i)
 179         {
 180             EXPECT_TRUE(dst[i] == src[i]);
 181             EXPECT_TRUE(dst[i + src.size()] == src[i]);
 182         }
 183     }
 184 }
 185
 186 #ifdef CONFIRM_COMPILATION_ERRORS
 187 TEST(algorithm_tests, incompatible_type)
 188 {
 189     std::array<int, 4> src{1, 2, 3, 4};
 190     std::array<int*, 12> dst{};
 191
 192     span<int> src_span_dyn(src);
 193     span<int, 4> src_span_static(src);
 194     span<int*> dst_span_dyn(dst);
 195     span<int*, 4> dst_span_static(dst);
 196
 197     // every line should produce a compilation error
 198     copy(src_span_dyn, dst_span_dyn);
 199     copy(src_span_dyn, dst_span_static);
 200     copy(src_span_static, dst_span_dyn);
 201     copy(src_span_static, dst_span_static);
 202 }
 203 #endif
 204
 205 TEST(algorithm_tests, small_destination_span)
 206 {
 207     std::set_terminate([] {
 208         std::cerr << "Expected Death. small_destination_span";
 209         std::abort();
 210     });
 211
 212     std::array<int, 12> src{1, 2, 3, 4};
 213     std::array<int, 4> dst{};
 214
 215     const span<int> src_span_dyn(src);
 216     const span<int, 12> src_span_static(src);
 217     const span<int> dst_span_dyn(dst);
 218     const span<int, 4> dst_span_static(dst);
 219
 220     EXPECT_DEATH(copy(src_span_dyn, dst_span_dyn), deathstring);
 221     EXPECT_DEATH(copy(src_span_dyn, dst_span_static), deathstring);
 222     EXPECT_DEATH(copy(src_span_static, dst_span_dyn), deathstring);
 223
 224 #ifdef CONFIRM_COMPILATION_ERRORS
 225     copy(src_span_static, dst_span_static);
 226 #endif
 227 }