Adding upstream version 18.2.2.upstream/18.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

9 files changed, 1008 insertions, 0 deletions

diff --git a/src/jaegertracing/opentelemetry-cpp/api/test/nostd/BUILD b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/BUILD
new file mode 100644
index 000000000..75166c5de
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/BUILD
@@ -0,0 +1,104 @@
+cc_test(
+    name = "function_ref_test",
+    srcs = [
+        "function_ref_test.cc",
+    ],
+    tags = [
+        "api",
+        "test",
+    ],
+    deps = [
+        "//api",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "string_view_test",
+    srcs = [
+        "string_view_test.cc",
+    ],
+    tags = [
+        "api",
+        "test",
+    ],
+    deps = [
+        "//api",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "variant_test",
+    srcs = [
+        "variant_test.cc",
+    ],
+    tags = [
+        "api",
+        "test",
+    ],
+    deps = [
+        "//api",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "unique_ptr_test",
+    srcs = [
+        "unique_ptr_test.cc",
+    ],
+    tags = [
+        "api",
+        "test",
+    ],
+    deps = [
+        "//api",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "utility_test",
+    srcs = [
+        "utility_test.cc",
+    ],
+    tags = [
+        "api",
+        "test",
+    ],
+    deps = [
+        "//api",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "span_test",
+    srcs = [
+        "span_test.cc",
+    ],
+    tags = [
+        "api",
+        "test",
+    ],
+    deps = [
+        "//api",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "shared_ptr_test",
+    srcs = [
+        "shared_ptr_test.cc",
+    ],
+    tags = [
+        "api",
+        "test",
+    ],
+    deps = [
+        "//api",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
diff --git a/src/jaegertracing/opentelemetry-cpp/api/test/nostd/CMakeLists.txt b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/CMakeLists.txt
new file mode 100644
index 000000000..dd783bf2d
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/CMakeLists.txt
@@ -0,0 +1,19 @@
+include(GoogleTest)
+
+foreach(
+  testname
+  function_ref_test
+  string_view_test
+  unique_ptr_test
+  utility_test
+  span_test
+  shared_ptr_test
+  variant_test)
+  add_executable(${testname} "${testname}.cc")
+  target_link_libraries(${testname} ${GTEST_BOTH_LIBRARIES}
+                        ${CMAKE_THREAD_LIBS_INIT} opentelemetry_api)
+  gtest_add_tests(
+    TARGET ${testname}
+    TEST_PREFIX nostd.
+    TEST_LIST ${testname})
+endforeach()
diff --git a/src/jaegertracing/opentelemetry-cpp/api/test/nostd/function_ref_test.cc b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/function_ref_test.cc
new file mode 100644
index 000000000..1153360d2
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/function_ref_test.cc
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/nostd/function_ref.h"
+
+#include <gtest/gtest.h>
+using namespace opentelemetry::nostd;
+
+int Call(function_ref<int()> f)
+{
+  return f();
+}
+
+int Return3()
+{
+  return 3;
+}
+
+TEST(FunctionRefTest, Call)
+{
+  int x = 9;
+
+  auto f = [&] { return x; };
+  EXPECT_EQ(Call(f), 9);
+
+  EXPECT_EQ(Call(Return3), 3);
+}
+
+TEST(FunctionRefTest, BoolConversion)
+{
+  auto f = [] { return 0; };
+  function_ref<int()> fref1{nullptr};
+  function_ref<int()> fref2{f};
+  EXPECT_TRUE(!static_cast<bool>(fref1));
+  EXPECT_TRUE(static_cast<bool>(fref2));
+}
diff --git a/src/jaegertracing/opentelemetry-cpp/api/test/nostd/shared_ptr_test.cc b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/shared_ptr_test.cc
new file mode 100644
index 000000000..6f3d43a77
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/shared_ptr_test.cc
@@ -0,0 +1,189 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/nostd/shared_ptr.h"
+
+#include <gtest/gtest.h>
+
+#include <algorithm>
+
+using opentelemetry::nostd::shared_ptr;
+
+class A
+{
+public:
+  explicit A(bool &destructed) noexcept : destructed_{destructed} { destructed_ = false; }
+
+  ~A() { destructed_ = true; }
+
+private:
+  bool &destructed_;
+};
+
+class B
+{
+public:
+  int f() const { return 123; }
+};
+
+class C
+{
+public:
+  virtual ~C() {}
+};
+
+class D : public C
+{
+public:
+  virtual ~D() {}
+};
+
+TEST(SharedPtrTest, DefaultConstruction)
+{
+  shared_ptr<int> ptr1;
+  EXPECT_EQ(ptr1.get(), nullptr);
+
+  shared_ptr<int> ptr2{nullptr};
+  EXPECT_EQ(ptr2.get(), nullptr);
+}
+
+TEST(SharedPtrTest, ExplicitConstruction)
+{
+  auto c = new C();
+  shared_ptr<C> ptr1{c};
+  EXPECT_EQ(ptr1.get(), c);
+
+  auto d = new D();
+  shared_ptr<C> ptr2{d};
+  EXPECT_EQ(ptr2.get(), d);
+}
+
+TEST(SharedPtrTest, MoveConstruction)
+{
+  auto value = new int{123};
+  shared_ptr<int> ptr1{value};
+  shared_ptr<int> ptr2{std::move(ptr1)};
+  EXPECT_EQ(ptr1.get(), nullptr);
+  EXPECT_EQ(ptr2.get(), value);
+}
+
+TEST(SharedPtrTest, MoveConstructionFromDifferentType)
+{
+  auto value = new int{123};
+  shared_ptr<int> ptr1{value};
+  shared_ptr<const int> ptr2{std::move(ptr1)};
+  EXPECT_EQ(ptr1.get(), nullptr);
+  EXPECT_EQ(ptr2.get(), value);
+}
+
+TEST(SharedPtrTest, MoveConstructionFromStdSharedPtr)
+{
+  auto value = new int{123};
+  std::shared_ptr<int> ptr1{value};
+  shared_ptr<int> ptr2{std::move(ptr1)};
+  EXPECT_EQ(ptr1.get(), nullptr);
+  EXPECT_EQ(ptr2.get(), value);
+}
+
+TEST(SharedPtrTest, Destruction)
+{
+  bool was_destructed;
+  shared_ptr<A>{new A{was_destructed}};
+  EXPECT_TRUE(was_destructed);
+}
+
+TEST(SharedPtrTest, Assignment)
+{
+  auto value = new int{123};
+  shared_ptr<int> ptr1;
+
+  ptr1 = shared_ptr<int>(value);
+  EXPECT_EQ(ptr1.get(), value);
+
+  ptr1 = nullptr;
+  EXPECT_EQ(ptr1.get(), nullptr);
+
+  auto value2                = new int{234};
+  const shared_ptr<int> ptr2 = shared_ptr<int>(value2);
+  ptr1                       = ptr2;
+  EXPECT_EQ(ptr1.get(), value2);
+
+  auto value3 = new int{345};
+  std::shared_ptr<int> ptr3(value3);
+  ptr1 = ptr3;
+  EXPECT_EQ(ptr1.get(), value3);
+}
+
+TEST(SharedPtrTest, BoolConversionOpertor)
+{
+  auto value = new int{123};
+  shared_ptr<int> ptr1{value};
+
+  EXPECT_TRUE(ptr1);
+  EXPECT_FALSE(shared_ptr<int>{});
+}
+
+TEST(SharedPtrTest, PointerOperators)
+{
+  auto value = new int{123};
+  shared_ptr<int> ptr1{value};
+
+  EXPECT_EQ(&*ptr1, value);
+  EXPECT_EQ(
+      shared_ptr<B> { new B }->f(), 123);
+}
+
+TEST(SharedPtrTest, Swap)
+{
+  auto value1 = new int{123};
+  shared_ptr<int> ptr1{value1};
+
+  auto value2 = new int{456};
+  shared_ptr<int> ptr2{value2};
+  ptr1.swap(ptr2);
+
+  EXPECT_EQ(ptr1.get(), value2);
+  EXPECT_EQ(ptr2.get(), value1);
+}
+
+TEST(SharedPtrTest, Comparison)
+{
+  shared_ptr<int> ptr1{new int{123}};
+  shared_ptr<int> ptr2{new int{456}};
+  shared_ptr<int> ptr3{};
+
+  EXPECT_EQ(ptr1, ptr1);
+  EXPECT_NE(ptr1, ptr2);
+
+  EXPECT_NE(ptr1, nullptr);
+  EXPECT_NE(nullptr, ptr1);
+
+  EXPECT_EQ(ptr3, nullptr);
+  EXPECT_EQ(nullptr, ptr3);
+}
+
+static void SharedPtrTest_Sort(size_t size = 10)
+{
+  std::vector<shared_ptr<const int>> nums;
+
+  for (int i = static_cast<int>(size); i > 0; i--)
+  {
+    nums.push_back(shared_ptr<int>(new int(i)));
+  }
+
+  auto nums2 = nums;
+
+  std::sort(nums.begin(), nums.end(),
+            [](shared_ptr<const int> a, shared_ptr<const int> b) { return *a < *b; });
+
+  EXPECT_NE(nums, nums2);
+
+  std::reverse(nums2.begin(), nums2.end());
+
+  EXPECT_EQ(nums, nums2);
+}
+
+TEST(SharedPtrTest, Sort)
+{
+  SharedPtrTest_Sort();
+}
diff --git a/src/jaegertracing/opentelemetry-cpp/api/test/nostd/span_test.cc b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/span_test.cc
new file mode 100644
index 000000000..09d32ecfb
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/span_test.cc
@@ -0,0 +1,191 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/nostd/span.h"
+
+#include <cstdint>
+
+#include <algorithm>
+#include <array>
+#include <iterator>
+#include <list>
+#include <type_traits>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+using opentelemetry::nostd::span;
+
+TEST(SpanTest, DefaultConstruction)
+{
+  span<int> s1;
+  EXPECT_EQ(s1.data(), nullptr);
+  EXPECT_EQ(s1.size(), 0);
+  EXPECT_TRUE(s1.empty());
+
+  span<int, 0> s2;
+  EXPECT_EQ(s2.data(), nullptr);
+  EXPECT_EQ(s2.size(), 0);
+  EXPECT_TRUE(s2.empty());
+
+  EXPECT_FALSE((std::is_default_constructible<span<int, 1>>::value));
+}
+
+TEST(SpanTest, Assignment)
+{
+  std::array<int, 3> array1 = {1, 2, 3};
+  std::array<int, 3> array2 = {1, 2, 3};
+  span<int> s1{array1.data(), array1.size()};
+  span<int, 3> s2{array1.data(), array1.size()};
+
+  span<int> s3;
+  s3 = s1;
+  EXPECT_EQ(s3.data(), array1.data());
+  EXPECT_EQ(s3.size(), array1.size());
+
+  span<int, 3> s4{array2};
+  s4 = s2;
+  EXPECT_EQ(s4.data(), array1.data());
+  EXPECT_EQ(s4.size(), array1.size());
+}
+
+TEST(SpanTest, PointerCountConstruction)
+{
+  std::array<int, 3> array = {1, 2, 3};
+
+  span<int> s1{array.data(), array.size()};
+  EXPECT_EQ(s1.data(), array.data());
+  EXPECT_EQ(s1.size(), array.size());
+
+  span<int, 3> s2{array.data(), array.size()};
+  EXPECT_EQ(s2.data(), array.data());
+  EXPECT_EQ(s2.size(), array.size());
+
+#ifndef HAVE_CPP_STDLIB
+  /* This test is not supposed to fail with STL. Why is this invalid construct? */
+  EXPECT_DEATH((span<int, 2>{array.data(), array.size()}), ".*");
+#endif
+}
+
+TEST(SpanTest, RangeConstruction)
+{
+  int array[] = {1, 2, 3};
+
+  span<int> s1{std::begin(array), std::end(array)};
+  EXPECT_EQ(s1.data(), array);
+  EXPECT_EQ(s1.size(), 3);
+
+  span<int, 3> s2{std::begin(array), std::end(array)};
+  EXPECT_EQ(s2.data(), array);
+  EXPECT_EQ(s2.size(), 3);
+
+#ifndef HAVE_CPP_STDLIB
+  /* This test is not supposed to fail with STL. Why is this invalid construct? */
+  EXPECT_DEATH((span<int, 2>{std::begin(array), std::end(array)}), ".*");
+#endif
+}
+
+TEST(SpanTest, ArrayConstruction)
+{
+  int array1[]              = {1, 2, 3};
+  std::array<int, 3> array2 = {1, 2, 3};
+
+  span<int> s1{array1};
+  EXPECT_EQ(s1.data(), array1);
+  EXPECT_EQ(s1.size(), 3);
+
+  span<int> s2{array2};
+  EXPECT_EQ(s2.data(), array2.data());
+  EXPECT_EQ(s2.size(), array2.size());
+
+  span<int, 3> s3{array1};
+  EXPECT_EQ(s3.data(), array1);
+  EXPECT_EQ(s3.size(), 3);
+
+  span<int, 3> s4{array2};
+  EXPECT_EQ(s4.data(), array2.data());
+  EXPECT_EQ(s4.size(), array2.size());
+
+  EXPECT_FALSE((std::is_constructible<span<int, 2>, int(&)[3]>::value));
+}
+
+TEST(SpanTest, ContainerConstruction)
+{
+  std::vector<int> v = {1, 2, 3};
+
+  span<int> s1{v};
+  EXPECT_EQ(s1.data(), v.data());
+  EXPECT_EQ(s1.size(), v.size());
+
+  span<int, 3> s2{v.data(), 3};
+
+  EXPECT_EQ(s2.data(), v.data());
+  EXPECT_EQ(s2.size(), v.size());
+
+#ifndef HAVE_CPP_STDLIB
+  /* This test is not supposed to fail with STL. Why is this invalid construct? */
+  EXPECT_DEATH((span<int, 2>{v.data(), 3}), ".*");
+#endif
+
+  EXPECT_FALSE((std::is_constructible<span<int>, std::vector<double>>::value));
+  EXPECT_FALSE((std::is_constructible<span<int>, std::list<int>>::value));
+}
+
+TEST(SpanTest, OtherSpanConstruction)
+{
+  std::array<int, 3> array = {1, 2, 3};
+  span<int> s1{array.data(), array.size()};
+  span<int, 3> s2{array.data(), array.size()};
+
+  span<int> s3{s1};
+  EXPECT_EQ(s3.data(), array.data());
+  EXPECT_EQ(s3.size(), array.size());
+
+  span<int> s4{s2};
+  EXPECT_EQ(s4.data(), array.data());
+  EXPECT_EQ(s4.size(), array.size());
+
+  span<const int> s5{s1};
+  EXPECT_EQ(s5.data(), array.data());
+  EXPECT_EQ(s5.size(), array.size());
+
+  EXPECT_FALSE((std::is_constructible<span<int>, span<const int>>::value));
+  EXPECT_FALSE((std::is_constructible<span<int>, span<double>>::value));
+
+  span<int, 3> s6{s2};
+  EXPECT_EQ(s6.data(), array.data());
+  EXPECT_EQ(s6.size(), array.size());
+
+  span<const int, 3> s7{s2};
+  EXPECT_EQ(s7.data(), array.data());
+  EXPECT_EQ(s7.size(), array.size());
+
+  EXPECT_FALSE((std::is_constructible<span<int, 3>, span<int, 4>>::value));
+  EXPECT_FALSE((std::is_constructible<span<int, 3>, span<double, 3>>::value));
+}
+
+TEST(SpanTest, BracketOperator)
+{
+  std::array<int, 2> array = {1, 2};
+
+  span<int> s1{array.data(), array.size()};
+  EXPECT_EQ(s1[0], 1);
+  EXPECT_EQ(s1[1], 2);
+
+  span<int, 2> s2{array.data(), array.size()};
+  EXPECT_EQ(s2[0], 1);
+  EXPECT_EQ(s2[1], 2);
+}
+
+TEST(SpanTest, Iteration)
+{
+  std::array<int, 3> array = {1, 2, 3};
+
+  span<int> s1{array.data(), array.size()};
+  EXPECT_EQ(std::distance(s1.begin(), s1.end()), array.size());
+  EXPECT_TRUE(std::equal(s1.begin(), s1.end(), array.begin()));
+
+  span<int, 3> s2{array.data(), array.size()};
+  EXPECT_EQ(std::distance(s2.begin(), s2.end()), array.size());
+  EXPECT_TRUE(std::equal(s2.begin(), s2.end(), array.begin()));
+}
diff --git a/src/jaegertracing/opentelemetry-cpp/api/test/nostd/string_view_test.cc b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/string_view_test.cc
new file mode 100644
index 000000000..fc580debc
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/string_view_test.cc
@@ -0,0 +1,125 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/nostd/string_view.h"
+
+#include <gtest/gtest.h>
+#include <cstring>
+#include <map>
+
+using opentelemetry::nostd::string_view;
+
+TEST(StringViewTest, DefaultConstruction)
+{
+  string_view ref;
+  EXPECT_EQ(ref.data(), nullptr);
+  EXPECT_EQ(ref.length(), 0);
+}
+
+TEST(StringViewTest, CStringInitialization)
+{
+  const char *val = "hello world";
+
+  string_view ref(val);
+
+  EXPECT_EQ(ref.data(), val);
+  EXPECT_EQ(ref.length(), std::strlen(val));
+}
+
+TEST(StringViewTest, StdStringInitialization)
+{
+  const std::string val = "hello world";
+
+  string_view ref(val);
+
+  EXPECT_EQ(ref.data(), val.data());
+  EXPECT_EQ(ref.length(), val.size());
+}
+
+TEST(StringViewTest, Copy)
+{
+  const std::string val = "hello world";
+
+  string_view ref(val);
+  string_view cpy(ref);
+
+  EXPECT_EQ(cpy.data(), val);
+  EXPECT_EQ(cpy.length(), val.length());
+  EXPECT_EQ(cpy, val);
+}
+
+TEST(StringViewTest, Accessor)
+{
+  string_view s = "abc123";
+  EXPECT_EQ(s.data(), &s[0]);
+  EXPECT_EQ(s.data() + 1, &s[1]);
+}
+
+TEST(StringViewTest, ExplicitStdStringConversion)
+{
+  std::string s = static_cast<std::string>(string_view{"abc"});
+  EXPECT_EQ(s, "abc");
+}
+
+TEST(StringViewTest, SubstrPortion)
+{
+  string_view s = "abc123";
+  EXPECT_EQ("123", s.substr(3));
+  EXPECT_EQ("12", s.substr(3, 2));
+}
+
+TEST(StringViewTest, SubstrOutOfRange)
+{
+  string_view s = "abc123";
+#if __EXCEPTIONS || defined(HAVE_CPP_STDLIB)
+  EXPECT_THROW(s.substr(10), std::out_of_range);
+#else
+  EXPECT_DEATH({ s.substr(10); }, "");
+#endif
+}
+
+TEST(StringViewTest, FindSingleCharacter)
+{
+  string_view s = "abc";
+
+  // starting from 0-th position (default)
+  EXPECT_EQ(s.find('a'), 0);
+  EXPECT_EQ(s.find('b'), 1);
+  EXPECT_EQ(s.find('c'), 2);
+  EXPECT_EQ(s.find('d'), -1);  // FIXME: string_view:npos - problem with linker
+
+  // starting from given index
+  EXPECT_EQ(s.find('a', 1), -1);
+  EXPECT_EQ(s.find('b', 1), 1);
+
+  // out of index
+  EXPECT_EQ(s.find('a', 10), -1);
+}
+
+TEST(StringViewTest, Compare)
+{
+  string_view s1 = "aaa";
+  string_view s2 = "bbb";
+  string_view s3 = "aaa";
+
+  // Equals
+  EXPECT_EQ(s1, s3);
+  EXPECT_EQ(s1, s1);
+
+  // Less then
+  EXPECT_LT(s1, s2);
+
+  // Greater then
+  EXPECT_GT(s2, s1);
+}
+
+TEST(StringViewTest, MapKeyOrdering)
+{
+  std::map<string_view, size_t> m = {{"bbb", 2}, {"aaa", 1}, {"ccc", 3}};
+  size_t i                        = 1;
+  for (const auto &kv : m)
+  {
+    EXPECT_EQ(kv.second, i);
+    i++;
+  }
+}
diff --git a/src/jaegertracing/opentelemetry-cpp/api/test/nostd/unique_ptr_test.cc b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/unique_ptr_test.cc
new file mode 100644
index 000000000..1d2e6c062
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/unique_ptr_test.cc
@@ -0,0 +1,169 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/nostd/unique_ptr.h"
+
+#include <gtest/gtest.h>
+
+using opentelemetry::nostd::unique_ptr;
+
+class A
+{
+public:
+  explicit A(bool &destructed) noexcept : destructed_{destructed} { destructed_ = false; }
+
+  ~A() { destructed_ = true; }
+
+private:
+  bool &destructed_;
+};
+
+class B
+{
+public:
+  int f() const { return 123; }
+};
+
+TEST(UniquePtrTest, DefaultConstruction)
+{
+  unique_ptr<int> ptr1;
+  EXPECT_EQ(ptr1.get(), nullptr);
+
+  unique_ptr<int> ptr2{nullptr};
+  EXPECT_EQ(ptr2.get(), nullptr);
+}
+
+TEST(UniquePtrTest, ExplicitConstruction)
+{
+  auto value = new int{123};
+  unique_ptr<int> ptr1{value};
+  EXPECT_EQ(ptr1.get(), value);
+
+  auto array = new int[5];
+  unique_ptr<int[]> ptr2{array};
+  EXPECT_EQ(ptr2.get(), array);
+}
+
+TEST(UniquePtrTest, MoveConstruction)
+{
+  auto value = new int{123};
+  unique_ptr<int> ptr1{value};
+  unique_ptr<int> ptr2{std::move(ptr1)};
+  EXPECT_EQ(ptr1.get(), nullptr);
+  EXPECT_EQ(ptr2.get(), value);
+}
+
+TEST(UniquePtrTest, MoveConstructionFromDifferentType)
+{
+  auto value = new int{123};
+  unique_ptr<int> ptr1{value};
+  unique_ptr<const int> ptr2{std::move(ptr1)};
+  EXPECT_EQ(ptr1.get(), nullptr);
+  EXPECT_EQ(ptr2.get(), value);
+}
+
+TEST(UniquePtrTest, MoveConstructionFromStdUniquePtr)
+{
+  auto value = new int{123};
+  std::unique_ptr<int> ptr1{value};
+  unique_ptr<int> ptr2{std::move(ptr1)};
+  EXPECT_EQ(ptr1.get(), nullptr);
+  EXPECT_EQ(ptr2.get(), value);
+}
+
+TEST(UniquePtrTest, Destruction)
+{
+  bool was_destructed;
+  unique_ptr<A>{new A{was_destructed}};
+  EXPECT_TRUE(was_destructed);
+}
+
+TEST(UniquePtrTest, StdUniquePtrConversionOperator)
+{
+  auto value = new int{123};
+  unique_ptr<int> ptr1{value};
+  std::unique_ptr<int> ptr2{std::move(ptr1)};
+  EXPECT_EQ(ptr1.get(), nullptr);
+  EXPECT_EQ(ptr2.get(), value);
+
+  value = new int{456};
+  ptr1  = unique_ptr<int>{value};
+  ptr2  = std::move(ptr1);
+  EXPECT_EQ(ptr1.get(), nullptr);
+  EXPECT_EQ(ptr2.get(), value);
+
+  ptr2 = nullptr;
+  EXPECT_EQ(ptr2.get(), nullptr);
+
+  EXPECT_TRUE((std::is_assignable<std::unique_ptr<int>, unique_ptr<int> &&>::value));
+  EXPECT_FALSE((std::is_assignable<std::unique_ptr<int>, unique_ptr<int> &>::value));
+}
+
+TEST(UniquePtrTest, BoolConversionOpertor)
+{
+  auto value = new int{123};
+  unique_ptr<int> ptr1{value};
+
+  EXPECT_TRUE(ptr1);
+  EXPECT_FALSE(unique_ptr<int>{});
+}
+
+TEST(UniquePtrTest, PointerOperators)
+{
+  auto value = new int{123};
+  unique_ptr<int> ptr1{value};
+
+  EXPECT_EQ(&*ptr1, value);
+  EXPECT_EQ(
+      unique_ptr<B> { new B }->f(), 123);
+}
+
+TEST(UniquePtrTest, Reset)
+{
+  bool was_destructed1;
+  unique_ptr<A> ptr{new A{was_destructed1}};
+  bool was_destructed2;
+  ptr.reset(new A{was_destructed2});
+  EXPECT_TRUE(was_destructed1);
+  EXPECT_FALSE(was_destructed2);
+  ptr.reset();
+  EXPECT_TRUE(was_destructed2);
+}
+
+TEST(UniquePtrTest, Release)
+{
+  auto value = new int{123};
+  unique_ptr<int> ptr{value};
+  EXPECT_EQ(ptr.release(), value);
+  EXPECT_EQ(ptr.get(), nullptr);
+  delete value;
+}
+
+TEST(UniquePtrTest, Swap)
+{
+  auto value1 = new int{123};
+  unique_ptr<int> ptr1{value1};
+
+  auto value2 = new int{456};
+  unique_ptr<int> ptr2{value2};
+  ptr1.swap(ptr2);
+
+  EXPECT_EQ(ptr1.get(), value2);
+  EXPECT_EQ(ptr2.get(), value1);
+}
+
+TEST(UniquePtrTest, Comparison)
+{
+  unique_ptr<int> ptr1{new int{123}};
+  unique_ptr<int> ptr2{new int{456}};
+  unique_ptr<int> ptr3{};
+
+  EXPECT_EQ(ptr1, ptr1);
+  EXPECT_NE(ptr1, ptr2);
+
+  EXPECT_NE(ptr1, nullptr);
+  EXPECT_NE(nullptr, ptr1);
+
+  EXPECT_EQ(ptr3, nullptr);
+  EXPECT_EQ(nullptr, ptr3);
+}
diff --git a/src/jaegertracing/opentelemetry-cpp/api/test/nostd/utility_test.cc b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/utility_test.cc
new file mode 100644
index 000000000..821b2a70a
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/utility_test.cc
@@ -0,0 +1,56 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/nostd/utility.h"
+
+#include <tuple>
+#include <type_traits>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace nostd = opentelemetry::nostd;
+
+template <class T>
+auto IsDataCallable(const T &t) -> decltype(nostd::data(t), std::true_type{});
+
+std::false_type IsDataCallable(...);
+
+template <class T>
+auto IsSizeCallable(const T &t) -> decltype(nostd::size(t), std::true_type{});
+
+std::false_type IsSizeCallable(...);
+
+TEST(UtilityTest, Data)
+{
+  std::vector<int> v = {1, 2, 3};
+  int array[3]       = {1, 2, 3};
+  std::initializer_list<int> list{1, 2, 3};
+  int x       = 0;
+  std::ignore = x;
+
+  EXPECT_EQ(nostd::data(v), v.data());
+  EXPECT_EQ(nostd::data(array), array);
+  EXPECT_EQ(nostd::data(list), list.begin());
+  EXPECT_FALSE(decltype(IsDataCallable(x)){});
+}
+
+TEST(UtilityTest, Size)
+{
+  std::vector<int> v = {1, 2, 3};
+  int array[3]       = {1, 2, 3};
+  int x              = 0;
+  std::ignore        = x;
+
+  EXPECT_EQ(nostd::size(v), v.size());
+  EXPECT_EQ(nostd::size(array), 3);
+
+  EXPECT_FALSE(decltype(IsSizeCallable(x)){});
+}
+
+TEST(UtilityTest, MakeIndexSequence)
+{
+  EXPECT_TRUE((std::is_same<nostd::make_index_sequence<0>, nostd::index_sequence<>>::value));
+  EXPECT_TRUE((std::is_same<nostd::make_index_sequence<1>, nostd::index_sequence<0>>::value));
+  EXPECT_TRUE((std::is_same<nostd::make_index_sequence<2>, nostd::index_sequence<0, 1>>::value));
+}
diff --git a/src/jaegertracing/opentelemetry-cpp/api/test/nostd/variant_test.cc b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/variant_test.cc
new file mode 100644
index 000000000..cea5c4ee7
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/api/test/nostd/variant_test.cc
@@ -0,0 +1,119 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/nostd/variant.h"
+
+#include <string>
+#include <type_traits>
+
+#include <gtest/gtest.h>
+
+namespace nostd = opentelemetry::nostd;
+
+class DestroyCounter
+{
+public:
+  explicit DestroyCounter(int *count) : count_{count} {}
+  ~DestroyCounter() { ++*count_; }
+
+private:
+  int *count_;
+};
+
+TEST(VariantSizeTest, GetVariantSize)
+{
+  EXPECT_EQ(nostd::variant_size<nostd::variant<>>::value, 0);
+  EXPECT_EQ(nostd::variant_size<nostd::variant<int>>::value, 1);
+  EXPECT_EQ((nostd::variant_size<nostd::variant<int, double>>::value), 2);
+}
+
+#if 0  // Disable this test for now. It does not compile with Visual Studio 2015.
+TEST(VariantAlternativeTest, GetVariantSize)
+{
+  EXPECT_TRUE((std::is_same<nostd::variant_alternative_t<0, nostd::variant<int>>, int>::value));
+  EXPECT_TRUE(
+      (std::is_same<nostd::variant_alternative_t<1, nostd::variant<int, double>>, double>::value));
+  EXPECT_TRUE((std::is_same<nostd::variant_alternative_t<1, const nostd::variant<int, double>>,
+                            const double>::value));
+}
+#endif
+
+TEST(VariantTest, Get)
+{
+  nostd::variant<int, float> v, w;
+  v = 12;
+  EXPECT_EQ(nostd::get<int>(v), 12);
+  EXPECT_EQ(nostd::get<0>(v), 12);
+  w = v;
+  EXPECT_EQ(nostd::get<int>(w), 12);
+  EXPECT_EQ(*nostd::get_if<int>(&v), 12);
+  EXPECT_EQ(nostd::get_if<float>(&v), nullptr);
+#if __EXCEPTIONS
+  EXPECT_THROW(nostd::get<float>(w), nostd::bad_variant_access);
+#else
+  EXPECT_DEATH({ nostd::get<float>(w); }, "");
+#endif
+}
+
+TEST(VariantTest, Comparison)
+{
+  nostd::variant<int, float> v, w;
+  EXPECT_TRUE(v == w);
+  EXPECT_FALSE(v != w);
+  v = 3.0f;
+  EXPECT_TRUE(v != w);
+  EXPECT_FALSE(v == w);
+  v = 2;
+  w = 3;
+  EXPECT_TRUE(v != w);
+  EXPECT_FALSE(v == w);
+  EXPECT_TRUE(v < w);
+  EXPECT_FALSE(v > w);
+}
+
+TEST(VariantTest, Visit)
+{
+  nostd::variant<int, float> v;
+  struct
+  {
+    int operator()(int) { return 0; }
+    int operator()(float) { return 1; }
+  } a;
+  EXPECT_EQ(nostd::visit(a, v), 0);
+  v = 2.0f;
+  EXPECT_EQ(nostd::visit(a, v), 1);
+}
+
+TEST(VariantTest, Destructor)
+{
+  nostd::variant<int, DestroyCounter> v;
+  int destroy_count = 0;
+  v                 = DestroyCounter{&destroy_count};
+  destroy_count     = 0;
+  v                 = 1;
+  EXPECT_EQ(destroy_count, 1);
+  {
+    nostd::variant<int, DestroyCounter> w;
+    w             = DestroyCounter{&destroy_count};
+    destroy_count = 0;
+  }
+  EXPECT_EQ(destroy_count, 1);
+}
+
+TEST(VariantTest, Conversion)
+{
+  nostd::variant<std::string> x("abc");
+  x = "def";
+  EXPECT_EQ(nostd::get<std::string>(x), "def");
+
+  nostd::variant<std::string, void const *> y("abc");
+  EXPECT_TRUE(nostd::holds_alternative<void const *>(y));
+  y = std::string{"xyz"};
+  EXPECT_TRUE(nostd::holds_alternative<std::string>(y));
+}
+
+TEST(VariantTest, Construction)
+{
+  nostd::variant<bool, const char *, std::string> v{"abc"};
+  EXPECT_EQ(v.index(), 1);
+}