ceph/src/jaegertracing/opentelemetry-cpp/api/test/nostd/span_test.cc

   1 // Copyright The OpenTelemetry Authors
   2 // SPDX-License-Identifier: Apache-2.0
   3
   4 #include "opentelemetry/nostd/span.h"
   5
   6 #include <cstdint>
   7
   8 #include <algorithm>
   9 #include <array>
  10 #include <iterator>
  11 #include <list>
  12 #include <type_traits>
  13 #include <vector>
  14
  15 #include <gtest/gtest.h>
  16
  17 using opentelemetry::nostd::span;
  18
  19 TEST(SpanTest, DefaultConstruction)
  20 {
  21   span<int> s1;
  22   EXPECT_EQ(s1.data(), nullptr);
  23   EXPECT_EQ(s1.size(), 0);
  24   EXPECT_TRUE(s1.empty());
  25
  26   span<int, 0> s2;
  27   EXPECT_EQ(s2.data(), nullptr);
  28   EXPECT_EQ(s2.size(), 0);
  29   EXPECT_TRUE(s2.empty());
  30
  31   EXPECT_FALSE((std::is_default_constructible<span<int, 1>>::value));
  32 }
  33
  34 TEST(SpanTest, Assignment)
  35 {
  36   std::array<int, 3> array1 = {1, 2, 3};
  37   std::array<int, 3> array2 = {1, 2, 3};
  38   span<int> s1{array1.data(), array1.size()};
  39   span<int, 3> s2{array1.data(), array1.size()};
  40
  41   span<int> s3;
  42   s3 = s1;
  43   EXPECT_EQ(s3.data(), array1.data());
  44   EXPECT_EQ(s3.size(), array1.size());
  45
  46   span<int, 3> s4{array2};
  47   s4 = s2;
  48   EXPECT_EQ(s4.data(), array1.data());
  49   EXPECT_EQ(s4.size(), array1.size());
  50 }
  51
  52 TEST(SpanTest, PointerCountConstruction)
  53 {
  54   std::array<int, 3> array = {1, 2, 3};
  55
  56   span<int> s1{array.data(), array.size()};
  57   EXPECT_EQ(s1.data(), array.data());
  58   EXPECT_EQ(s1.size(), array.size());
  59
  60   span<int, 3> s2{array.data(), array.size()};
  61   EXPECT_EQ(s2.data(), array.data());
  62   EXPECT_EQ(s2.size(), array.size());
  63
  64 #ifndef HAVE_CPP_STDLIB
  65   /* This test is not supposed to fail with STL. Why is this invalid construct? */
  66   EXPECT_DEATH((span<int, 2>{array.data(), array.size()}), ".*");
  67 #endif
  68 }
  69
  70 TEST(SpanTest, RangeConstruction)
  71 {
  72   int array[] = {1, 2, 3};
  73
  74   span<int> s1{std::begin(array), std::end(array)};
  75   EXPECT_EQ(s1.data(), array);
  76   EXPECT_EQ(s1.size(), 3);
  77
  78   span<int, 3> s2{std::begin(array), std::end(array)};
  79   EXPECT_EQ(s2.data(), array);
  80   EXPECT_EQ(s2.size(), 3);
  81
  82 #ifndef HAVE_CPP_STDLIB
  83   /* This test is not supposed to fail with STL. Why is this invalid construct? */
  84   EXPECT_DEATH((span<int, 2>{std::begin(array), std::end(array)}), ".*");
  85 #endif
  86 }
  87
  88 TEST(SpanTest, ArrayConstruction)
  89 {
  90   int array1[]              = {1, 2, 3};
  91   std::array<int, 3> array2 = {1, 2, 3};
  92
  93   span<int> s1{array1};
  94   EXPECT_EQ(s1.data(), array1);
  95   EXPECT_EQ(s1.size(), 3);
  96
  97   span<int> s2{array2};
  98   EXPECT_EQ(s2.data(), array2.data());
  99   EXPECT_EQ(s2.size(), array2.size());
 100
 101   span<int, 3> s3{array1};
 102   EXPECT_EQ(s3.data(), array1);
 103   EXPECT_EQ(s3.size(), 3);
 104
 105   span<int, 3> s4{array2};
 106   EXPECT_EQ(s4.data(), array2.data());
 107   EXPECT_EQ(s4.size(), array2.size());
 108
 109   EXPECT_FALSE((std::is_constructible<span<int, 2>, int(&)[3]>::value));
 110 }
 111
 112 TEST(SpanTest, ContainerConstruction)
 113 {
 114   std::vector<int> v = {1, 2, 3};
 115
 116   span<int> s1{v};
 117   EXPECT_EQ(s1.data(), v.data());
 118   EXPECT_EQ(s1.size(), v.size());
 119
 120   span<int, 3> s2{v.data(), 3};
 121
 122   EXPECT_EQ(s2.data(), v.data());
 123   EXPECT_EQ(s2.size(), v.size());
 124
 125 #ifndef HAVE_CPP_STDLIB
 126   /* This test is not supposed to fail with STL. Why is this invalid construct? */
 127   EXPECT_DEATH((span<int, 2>{v.data(), 3}), ".*");
 128 #endif
 129
 130   EXPECT_FALSE((std::is_constructible<span<int>, std::vector<double>>::value));
 131   EXPECT_FALSE((std::is_constructible<span<int>, std::list<int>>::value));
 132 }
 133
 134 TEST(SpanTest, OtherSpanConstruction)
 135 {
 136   std::array<int, 3> array = {1, 2, 3};
 137   span<int> s1{array.data(), array.size()};
 138   span<int, 3> s2{array.data(), array.size()};
 139
 140   span<int> s3{s1};
 141   EXPECT_EQ(s3.data(), array.data());
 142   EXPECT_EQ(s3.size(), array.size());
 143
 144   span<int> s4{s2};
 145   EXPECT_EQ(s4.data(), array.data());
 146   EXPECT_EQ(s4.size(), array.size());
 147
 148   span<const int> s5{s1};
 149   EXPECT_EQ(s5.data(), array.data());
 150   EXPECT_EQ(s5.size(), array.size());
 151
 152   EXPECT_FALSE((std::is_constructible<span<int>, span<const int>>::value));
 153   EXPECT_FALSE((std::is_constructible<span<int>, span<double>>::value));
 154
 155   span<int, 3> s6{s2};
 156   EXPECT_EQ(s6.data(), array.data());
 157   EXPECT_EQ(s6.size(), array.size());
 158
 159   span<const int, 3> s7{s2};
 160   EXPECT_EQ(s7.data(), array.data());
 161   EXPECT_EQ(s7.size(), array.size());
 162
 163   EXPECT_FALSE((std::is_constructible<span<int, 3>, span<int, 4>>::value));
 164   EXPECT_FALSE((std::is_constructible<span<int, 3>, span<double, 3>>::value));
 165 }
 166
 167 TEST(SpanTest, BracketOperator)
 168 {
 169   std::array<int, 2> array = {1, 2};
 170
 171   span<int> s1{array.data(), array.size()};
 172   EXPECT_EQ(s1[0], 1);
 173   EXPECT_EQ(s1[1], 2);
 174
 175   span<int, 2> s2{array.data(), array.size()};
 176   EXPECT_EQ(s2[0], 1);
 177   EXPECT_EQ(s2[1], 2);
 178 }
 179
 180 TEST(SpanTest, Iteration)
 181 {
 182   std::array<int, 3> array = {1, 2, 3};
 183
 184   span<int> s1{array.data(), array.size()};
 185   EXPECT_EQ(std::distance(s1.begin(), s1.end()), array.size());
 186   EXPECT_TRUE(std::equal(s1.begin(), s1.end(), array.begin()));
 187
 188   span<int, 3> s2{array.data(), array.size()};
 189   EXPECT_EQ(std::distance(s2.begin(), s2.end()), array.size());
 190   EXPECT_TRUE(std::equal(s2.begin(), s2.end(), array.begin()));
 191 }