From e6918187568dbd01842d8d1d2c808ce16a894239 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 21 Apr 2024 13:54:28 +0200 Subject: Adding upstream version 18.2.2. Signed-off-by: Daniel Baumann --- .../opentelemetry-cpp/api/test/nostd/BUILD | 104 +++++++++++ .../api/test/nostd/CMakeLists.txt | 19 ++ .../api/test/nostd/function_ref_test.cc | 36 ++++ .../api/test/nostd/shared_ptr_test.cc | 189 ++++++++++++++++++++ .../opentelemetry-cpp/api/test/nostd/span_test.cc | 191 +++++++++++++++++++++ .../api/test/nostd/string_view_test.cc | 125 ++++++++++++++ .../api/test/nostd/unique_ptr_test.cc | 169 ++++++++++++++++++ .../api/test/nostd/utility_test.cc | 56 ++++++ .../api/test/nostd/variant_test.cc | 119 +++++++++++++ 9 files changed, 1008 insertions(+) create mode 100644 src/jaegertracing/opentelemetry-cpp/api/test/nostd/BUILD create mode 100644 src/jaegertracing/opentelemetry-cpp/api/test/nostd/CMakeLists.txt create mode 100644 src/jaegertracing/opentelemetry-cpp/api/test/nostd/function_ref_test.cc create mode 100644 src/jaegertracing/opentelemetry-cpp/api/test/nostd/shared_ptr_test.cc create mode 100644 src/jaegertracing/opentelemetry-cpp/api/test/nostd/span_test.cc create mode 100644 src/jaegertracing/opentelemetry-cpp/api/test/nostd/string_view_test.cc create mode 100644 src/jaegertracing/opentelemetry-cpp/api/test/nostd/unique_ptr_test.cc create mode 100644 src/jaegertracing/opentelemetry-cpp/api/test/nostd/utility_test.cc create mode 100644 src/jaegertracing/opentelemetry-cpp/api/test/nostd/variant_test.cc (limited to 'src/jaegertracing/opentelemetry-cpp/api/test/nostd') 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 +using namespace opentelemetry::nostd; + +int Call(function_ref 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 fref1{nullptr}; + function_ref fref2{f}; + EXPECT_TRUE(!static_cast(fref1)); + EXPECT_TRUE(static_cast(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 + +#include + +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 ptr1; + EXPECT_EQ(ptr1.get(), nullptr); + + shared_ptr ptr2{nullptr}; + EXPECT_EQ(ptr2.get(), nullptr); +} + +TEST(SharedPtrTest, ExplicitConstruction) +{ + auto c = new C(); + shared_ptr ptr1{c}; + EXPECT_EQ(ptr1.get(), c); + + auto d = new D(); + shared_ptr ptr2{d}; + EXPECT_EQ(ptr2.get(), d); +} + +TEST(SharedPtrTest, MoveConstruction) +{ + auto value = new int{123}; + shared_ptr ptr1{value}; + shared_ptr ptr2{std::move(ptr1)}; + EXPECT_EQ(ptr1.get(), nullptr); + EXPECT_EQ(ptr2.get(), value); +} + +TEST(SharedPtrTest, MoveConstructionFromDifferentType) +{ + auto value = new int{123}; + shared_ptr ptr1{value}; + shared_ptr 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 ptr1{value}; + shared_ptr ptr2{std::move(ptr1)}; + EXPECT_EQ(ptr1.get(), nullptr); + EXPECT_EQ(ptr2.get(), value); +} + +TEST(SharedPtrTest, Destruction) +{ + bool was_destructed; + shared_ptr{new A{was_destructed}}; + EXPECT_TRUE(was_destructed); +} + +TEST(SharedPtrTest, Assignment) +{ + auto value = new int{123}; + shared_ptr ptr1; + + ptr1 = shared_ptr(value); + EXPECT_EQ(ptr1.get(), value); + + ptr1 = nullptr; + EXPECT_EQ(ptr1.get(), nullptr); + + auto value2 = new int{234}; + const shared_ptr ptr2 = shared_ptr(value2); + ptr1 = ptr2; + EXPECT_EQ(ptr1.get(), value2); + + auto value3 = new int{345}; + std::shared_ptr ptr3(value3); + ptr1 = ptr3; + EXPECT_EQ(ptr1.get(), value3); +} + +TEST(SharedPtrTest, BoolConversionOpertor) +{ + auto value = new int{123}; + shared_ptr ptr1{value}; + + EXPECT_TRUE(ptr1); + EXPECT_FALSE(shared_ptr{}); +} + +TEST(SharedPtrTest, PointerOperators) +{ + auto value = new int{123}; + shared_ptr ptr1{value}; + + EXPECT_EQ(&*ptr1, value); + EXPECT_EQ( + shared_ptr { new B }->f(), 123); +} + +TEST(SharedPtrTest, Swap) +{ + auto value1 = new int{123}; + shared_ptr ptr1{value1}; + + auto value2 = new int{456}; + shared_ptr ptr2{value2}; + ptr1.swap(ptr2); + + EXPECT_EQ(ptr1.get(), value2); + EXPECT_EQ(ptr2.get(), value1); +} + +TEST(SharedPtrTest, Comparison) +{ + shared_ptr ptr1{new int{123}}; + shared_ptr ptr2{new int{456}}; + shared_ptr 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> nums; + + for (int i = static_cast(size); i > 0; i--) + { + nums.push_back(shared_ptr(new int(i))); + } + + auto nums2 = nums; + + std::sort(nums.begin(), nums.end(), + [](shared_ptr a, shared_ptr 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 + +#include +#include +#include +#include +#include +#include + +#include + +using opentelemetry::nostd::span; + +TEST(SpanTest, DefaultConstruction) +{ + span s1; + EXPECT_EQ(s1.data(), nullptr); + EXPECT_EQ(s1.size(), 0); + EXPECT_TRUE(s1.empty()); + + span s2; + EXPECT_EQ(s2.data(), nullptr); + EXPECT_EQ(s2.size(), 0); + EXPECT_TRUE(s2.empty()); + + EXPECT_FALSE((std::is_default_constructible>::value)); +} + +TEST(SpanTest, Assignment) +{ + std::array array1 = {1, 2, 3}; + std::array array2 = {1, 2, 3}; + span s1{array1.data(), array1.size()}; + span s2{array1.data(), array1.size()}; + + span s3; + s3 = s1; + EXPECT_EQ(s3.data(), array1.data()); + EXPECT_EQ(s3.size(), array1.size()); + + span s4{array2}; + s4 = s2; + EXPECT_EQ(s4.data(), array1.data()); + EXPECT_EQ(s4.size(), array1.size()); +} + +TEST(SpanTest, PointerCountConstruction) +{ + std::array array = {1, 2, 3}; + + span s1{array.data(), array.size()}; + EXPECT_EQ(s1.data(), array.data()); + EXPECT_EQ(s1.size(), array.size()); + + span 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{array.data(), array.size()}), ".*"); +#endif +} + +TEST(SpanTest, RangeConstruction) +{ + int array[] = {1, 2, 3}; + + span s1{std::begin(array), std::end(array)}; + EXPECT_EQ(s1.data(), array); + EXPECT_EQ(s1.size(), 3); + + span 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{std::begin(array), std::end(array)}), ".*"); +#endif +} + +TEST(SpanTest, ArrayConstruction) +{ + int array1[] = {1, 2, 3}; + std::array array2 = {1, 2, 3}; + + span s1{array1}; + EXPECT_EQ(s1.data(), array1); + EXPECT_EQ(s1.size(), 3); + + span s2{array2}; + EXPECT_EQ(s2.data(), array2.data()); + EXPECT_EQ(s2.size(), array2.size()); + + span s3{array1}; + EXPECT_EQ(s3.data(), array1); + EXPECT_EQ(s3.size(), 3); + + span s4{array2}; + EXPECT_EQ(s4.data(), array2.data()); + EXPECT_EQ(s4.size(), array2.size()); + + EXPECT_FALSE((std::is_constructible, int(&)[3]>::value)); +} + +TEST(SpanTest, ContainerConstruction) +{ + std::vector v = {1, 2, 3}; + + span s1{v}; + EXPECT_EQ(s1.data(), v.data()); + EXPECT_EQ(s1.size(), v.size()); + + span 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{v.data(), 3}), ".*"); +#endif + + EXPECT_FALSE((std::is_constructible, std::vector>::value)); + EXPECT_FALSE((std::is_constructible, std::list>::value)); +} + +TEST(SpanTest, OtherSpanConstruction) +{ + std::array array = {1, 2, 3}; + span s1{array.data(), array.size()}; + span s2{array.data(), array.size()}; + + span s3{s1}; + EXPECT_EQ(s3.data(), array.data()); + EXPECT_EQ(s3.size(), array.size()); + + span s4{s2}; + EXPECT_EQ(s4.data(), array.data()); + EXPECT_EQ(s4.size(), array.size()); + + span s5{s1}; + EXPECT_EQ(s5.data(), array.data()); + EXPECT_EQ(s5.size(), array.size()); + + EXPECT_FALSE((std::is_constructible, span>::value)); + EXPECT_FALSE((std::is_constructible, span>::value)); + + span s6{s2}; + EXPECT_EQ(s6.data(), array.data()); + EXPECT_EQ(s6.size(), array.size()); + + span s7{s2}; + EXPECT_EQ(s7.data(), array.data()); + EXPECT_EQ(s7.size(), array.size()); + + EXPECT_FALSE((std::is_constructible, span>::value)); + EXPECT_FALSE((std::is_constructible, span>::value)); +} + +TEST(SpanTest, BracketOperator) +{ + std::array array = {1, 2}; + + span s1{array.data(), array.size()}; + EXPECT_EQ(s1[0], 1); + EXPECT_EQ(s1[1], 2); + + span s2{array.data(), array.size()}; + EXPECT_EQ(s2[0], 1); + EXPECT_EQ(s2[1], 2); +} + +TEST(SpanTest, Iteration) +{ + std::array array = {1, 2, 3}; + + span 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 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 +#include +#include + +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(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 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 + +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 ptr1; + EXPECT_EQ(ptr1.get(), nullptr); + + unique_ptr ptr2{nullptr}; + EXPECT_EQ(ptr2.get(), nullptr); +} + +TEST(UniquePtrTest, ExplicitConstruction) +{ + auto value = new int{123}; + unique_ptr ptr1{value}; + EXPECT_EQ(ptr1.get(), value); + + auto array = new int[5]; + unique_ptr ptr2{array}; + EXPECT_EQ(ptr2.get(), array); +} + +TEST(UniquePtrTest, MoveConstruction) +{ + auto value = new int{123}; + unique_ptr ptr1{value}; + unique_ptr ptr2{std::move(ptr1)}; + EXPECT_EQ(ptr1.get(), nullptr); + EXPECT_EQ(ptr2.get(), value); +} + +TEST(UniquePtrTest, MoveConstructionFromDifferentType) +{ + auto value = new int{123}; + unique_ptr ptr1{value}; + unique_ptr 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 ptr1{value}; + unique_ptr ptr2{std::move(ptr1)}; + EXPECT_EQ(ptr1.get(), nullptr); + EXPECT_EQ(ptr2.get(), value); +} + +TEST(UniquePtrTest, Destruction) +{ + bool was_destructed; + unique_ptr{new A{was_destructed}}; + EXPECT_TRUE(was_destructed); +} + +TEST(UniquePtrTest, StdUniquePtrConversionOperator) +{ + auto value = new int{123}; + unique_ptr ptr1{value}; + std::unique_ptr ptr2{std::move(ptr1)}; + EXPECT_EQ(ptr1.get(), nullptr); + EXPECT_EQ(ptr2.get(), value); + + value = new int{456}; + ptr1 = unique_ptr{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, unique_ptr &&>::value)); + EXPECT_FALSE((std::is_assignable, unique_ptr &>::value)); +} + +TEST(UniquePtrTest, BoolConversionOpertor) +{ + auto value = new int{123}; + unique_ptr ptr1{value}; + + EXPECT_TRUE(ptr1); + EXPECT_FALSE(unique_ptr{}); +} + +TEST(UniquePtrTest, PointerOperators) +{ + auto value = new int{123}; + unique_ptr ptr1{value}; + + EXPECT_EQ(&*ptr1, value); + EXPECT_EQ( + unique_ptr { new B }->f(), 123); +} + +TEST(UniquePtrTest, Reset) +{ + bool was_destructed1; + unique_ptr 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 ptr{value}; + EXPECT_EQ(ptr.release(), value); + EXPECT_EQ(ptr.get(), nullptr); + delete value; +} + +TEST(UniquePtrTest, Swap) +{ + auto value1 = new int{123}; + unique_ptr ptr1{value1}; + + auto value2 = new int{456}; + unique_ptr ptr2{value2}; + ptr1.swap(ptr2); + + EXPECT_EQ(ptr1.get(), value2); + EXPECT_EQ(ptr2.get(), value1); +} + +TEST(UniquePtrTest, Comparison) +{ + unique_ptr ptr1{new int{123}}; + unique_ptr ptr2{new int{456}}; + unique_ptr 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 +#include +#include + +#include + +namespace nostd = opentelemetry::nostd; + +template +auto IsDataCallable(const T &t) -> decltype(nostd::data(t), std::true_type{}); + +std::false_type IsDataCallable(...); + +template +auto IsSizeCallable(const T &t) -> decltype(nostd::size(t), std::true_type{}); + +std::false_type IsSizeCallable(...); + +TEST(UtilityTest, Data) +{ + std::vector v = {1, 2, 3}; + int array[3] = {1, 2, 3}; + std::initializer_list 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 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::index_sequence<>>::value)); + EXPECT_TRUE((std::is_same, nostd::index_sequence<0>>::value)); + EXPECT_TRUE((std::is_same, 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 +#include + +#include + +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>::value, 0); + EXPECT_EQ(nostd::variant_size>::value, 1); + EXPECT_EQ((nostd::variant_size>::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>, int>::value)); + EXPECT_TRUE( + (std::is_same>, double>::value)); + EXPECT_TRUE((std::is_same>, + const double>::value)); +} +#endif + +TEST(VariantTest, Get) +{ + nostd::variant v, w; + v = 12; + EXPECT_EQ(nostd::get(v), 12); + EXPECT_EQ(nostd::get<0>(v), 12); + w = v; + EXPECT_EQ(nostd::get(w), 12); + EXPECT_EQ(*nostd::get_if(&v), 12); + EXPECT_EQ(nostd::get_if(&v), nullptr); +#if __EXCEPTIONS + EXPECT_THROW(nostd::get(w), nostd::bad_variant_access); +#else + EXPECT_DEATH({ nostd::get(w); }, ""); +#endif +} + +TEST(VariantTest, Comparison) +{ + nostd::variant 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 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 v; + int destroy_count = 0; + v = DestroyCounter{&destroy_count}; + destroy_count = 0; + v = 1; + EXPECT_EQ(destroy_count, 1); + { + nostd::variant w; + w = DestroyCounter{&destroy_count}; + destroy_count = 0; + } + EXPECT_EQ(destroy_count, 1); +} + +TEST(VariantTest, Conversion) +{ + nostd::variant x("abc"); + x = "def"; + EXPECT_EQ(nostd::get(x), "def"); + + nostd::variant y("abc"); + EXPECT_TRUE(nostd::holds_alternative(y)); + y = std::string{"xyz"}; + EXPECT_TRUE(nostd::holds_alternative(y)); +} + +TEST(VariantTest, Construction) +{ + nostd::variant v{"abc"}; + EXPECT_EQ(v.index(), 1); +} -- cgit v1.2.3