diff options
Diffstat (limited to 'src/jaegertracing/opentracing-cpp/test')
10 files changed, 365 insertions, 0 deletions
diff --git a/src/jaegertracing/opentracing-cpp/test/BUILD b/src/jaegertracing/opentracing-cpp/test/BUILD new file mode 100644 index 000000000..ce9077bcf --- /dev/null +++ b/src/jaegertracing/opentracing-cpp/test/BUILD @@ -0,0 +1,27 @@ +TEST_NAMES = [ + "string_view_test", + "tracer_test", + "util_test", + "value_test", +] + +[cc_test( + name = test_name, + srcs = [test_name + ".cpp"], + deps = [ + "//:opentracing", + "//3rd_party:catch2", + ], +) for test_name in TEST_NAMES] + +cc_test( + name = "mutiple_tracer_link_test", + srcs = [ + "multiple_tracer_link_test.cpp", + "tracer_a.cpp", + "tracer_b.cpp", + ], + deps = [ + "//:opentracing", + ] +) diff --git a/src/jaegertracing/opentracing-cpp/test/CMakeLists.txt b/src/jaegertracing/opentracing-cpp/test/CMakeLists.txt new file mode 100644 index 000000000..fa2b0ca0c --- /dev/null +++ b/src/jaegertracing/opentracing-cpp/test/CMakeLists.txt @@ -0,0 +1,32 @@ +if (BUILD_SHARED_LIBS) + set(OPENTRACING_LIBRARY opentracing) +else() + set(OPENTRACING_LIBRARY opentracing-static) +endif() + +add_executable(tracer_test tracer_test.cpp) +target_link_libraries(tracer_test ${OPENTRACING_LIBRARY}) +add_test(NAME tracer_test COMMAND tracer_test) + +add_executable(string_view_test string_view_test.cpp) +add_test(NAME string_view_test COMMAND string_view_test) + +add_executable(value_test value_test.cpp) +add_test(NAME value_test COMMAND value_test) + +add_executable(util_test util_test.cpp) +add_test(NAME util_test COMMAND util_test) + +if (BUILD_SHARED_LIBS AND BUILD_MOCKTRACER AND BUILD_DYNAMIC_LOADING) + add_executable(dynamic_load_test dynamic_load_test.cpp) + target_link_libraries(dynamic_load_test ${OPENTRACING_LIBRARY}) + add_dependencies(dynamic_load_test opentracing_mocktracer) + add_test(NAME dynamic_load_test COMMAND dynamic_load_test + --mocktracer_library + $<TARGET_FILE:opentracing_mocktracer>) + + add_executable(multiple_tracer_link_test multiple_tracer_link_test.cpp + tracer_a.cpp tracer_b.cpp) + target_link_libraries(multiple_tracer_link_test ${OPENTRACING_LIBRARY}) + add_test(NAME multiple_tracer_link_test COMMAND multiple_tracer_link_test) +endif() diff --git a/src/jaegertracing/opentracing-cpp/test/dynamic_load_test.cpp b/src/jaegertracing/opentracing-cpp/test/dynamic_load_test.cpp new file mode 100644 index 000000000..8ad76e384 --- /dev/null +++ b/src/jaegertracing/opentracing-cpp/test/dynamic_load_test.cpp @@ -0,0 +1,90 @@ +#include <opentracing/dynamic_load.h> +#include <cstdio> +#include <fstream> +#include <iterator> +#include <random> +using namespace opentracing; + +#define CATCH_CONFIG_RUNNER +#include <opentracing/catch2/catch.hpp> + +static std::string mocktracer_library; + +TEST_CASE("dynamic_load") { + std::string error_message; + + SECTION( + "Dynamically loading a library that doesn't exists gives a proper error " + "code.") { + auto handle_maybe = DynamicallyLoadTracingLibrary("abc/123", error_message); + REQUIRE(!handle_maybe); + CHECK(handle_maybe.error() == dynamic_load_failure_error); + } + + error_message.clear(); + auto handle_maybe = + DynamicallyLoadTracingLibrary(mocktracer_library.c_str(), error_message); + REQUIRE(handle_maybe); + REQUIRE(error_message.empty()); + + SECTION("Creating a tracer from invalid json gives an error.") { + auto tracer_maybe = + handle_maybe->tracer_factory().MakeTracer("abc 123", error_message); + REQUIRE(!tracer_maybe); + } + + SECTION("Creating a tracer with an invalid output_file gives an error.") { + auto tracer_maybe = handle_maybe->tracer_factory().MakeTracer( + R"({"output_file": ""})", error_message); + REQUIRE(!tracer_maybe); + REQUIRE(tracer_maybe.error() == invalid_configuration_error); + } + + SECTION( + "We can create spans from an OpenTracing library dynamically loaded.") { + std::string span_filename{"spans."}; + const auto random_id = std::random_device{}(); + span_filename.append(std::to_string(random_id)); + std::string configuration = R"({ "output_file": ")"; + configuration.append(span_filename); + configuration.append(R"(" })"); + + { + auto tracer_maybe = handle_maybe->tracer_factory().MakeTracer( + configuration.c_str(), error_message); + REQUIRE(tracer_maybe); + auto tracer = *tracer_maybe; + tracer->StartSpan("abc"); + tracer->Close(); + } + + std::ifstream istream{span_filename}; + REQUIRE(istream.good()); + std::string spans_json{std::istreambuf_iterator<char>{istream}, + std::istreambuf_iterator<char>{}}; + istream.close(); + std::remove(span_filename.c_str()); + CHECK(!spans_json.empty()); + } +} + +int main(int argc, char* argv[]) { + Catch::Session session; + + using namespace Catch::clara; + auto cli = session.cli() | Opt(mocktracer_library, + "mocktracer_library")["--mocktracer_library"]; + + session.cli(cli); + int rcode = session.applyCommandLine(argc, argv); + if (rcode != 0) { + return rcode; + } + + if (mocktracer_library.empty()) { + std::cerr << "Must provide mocktracer_library!\n"; + return -1; + } + + return session.run(); +} diff --git a/src/jaegertracing/opentracing-cpp/test/multiple_tracer_link_test.cpp b/src/jaegertracing/opentracing-cpp/test/multiple_tracer_link_test.cpp new file mode 100644 index 000000000..60a9425ac --- /dev/null +++ b/src/jaegertracing/opentracing-cpp/test/multiple_tracer_link_test.cpp @@ -0,0 +1,16 @@ +// Links in tracer_a.o and tracer_b.o to verify that there's no multiple +// definition error from OpenTracingMakeTracerFactory. +#include <opentracing/dynamic_load.h> + +extern "C" { +extern OpenTracingMakeTracerFactoryType* const OpenTracingMakeTracerFactory; +} // extern "C" + +int main() { + // Call OpenTracingMakeTracerFactory to make sure it's not elided. + if ((*OpenTracingMakeTracerFactory)(nullptr, nullptr, nullptr, nullptr, + nullptr) != -1) { + return -1; + } + return 0; +} diff --git a/src/jaegertracing/opentracing-cpp/test/string_view_test.cpp b/src/jaegertracing/opentracing-cpp/test/string_view_test.cpp new file mode 100644 index 000000000..33a8bc47c --- /dev/null +++ b/src/jaegertracing/opentracing-cpp/test/string_view_test.cpp @@ -0,0 +1,49 @@ +#include <opentracing/string_view.h> // test include guard +#include <opentracing/string_view.h> + +#define CATCH_CONFIG_MAIN +#include <opentracing/catch2/catch.hpp> + +using namespace opentracing; + +TEST_CASE("string_view") { + SECTION("A default-constructed string_view is empty.") { + string_view ref; + CHECK(nullptr == ref.data()); + CHECK(0 == ref.length()); + } + + SECTION("string_view can be initialized from a c-string.") { + const char* val = "hello world"; + + string_view ref(val); + + CHECK(val == ref.data()); + CHECK(std::strlen(val) == ref.length()); + } + + SECTION("string_view can be initialized from an std::string.") { + const std::string val = "hello world"; + + string_view ref(val); + + CHECK(val == ref.data()); + CHECK(val.length() == ref.length()); + } + + SECTION("A copied string_view points to the same data as its source.") { + const std::string val = "hello world"; + + string_view ref(val); + string_view cpy(ref); + + CHECK(val == cpy.data()); + CHECK(val.length() == cpy.length()); + } + + SECTION("operator[] can be used to access characters in a string_view") { + string_view s = "abc123"; + CHECK(&s[0] == s.data()); + CHECK(&s[1] == s.data() + 1); + } +} diff --git a/src/jaegertracing/opentracing-cpp/test/tracer_a.cpp b/src/jaegertracing/opentracing-cpp/test/tracer_a.cpp new file mode 100644 index 000000000..457b1ddab --- /dev/null +++ b/src/jaegertracing/opentracing-cpp/test/tracer_a.cpp @@ -0,0 +1,10 @@ +#include <opentracing/dynamic_load.h> + +static int OpenTracingMakeTracerFactoryFct( + const char* /*opentracing_version*/, + const char* /*opentracing_abi_version*/, const void** /*error_category*/, + void* /*error_message*/, void** /*tracer_factory*/) { + return -1; +} + +OPENTRACING_DECLARE_IMPL_FACTORY(OpenTracingMakeTracerFactoryFct); diff --git a/src/jaegertracing/opentracing-cpp/test/tracer_b.cpp b/src/jaegertracing/opentracing-cpp/test/tracer_b.cpp new file mode 100644 index 000000000..457b1ddab --- /dev/null +++ b/src/jaegertracing/opentracing-cpp/test/tracer_b.cpp @@ -0,0 +1,10 @@ +#include <opentracing/dynamic_load.h> + +static int OpenTracingMakeTracerFactoryFct( + const char* /*opentracing_version*/, + const char* /*opentracing_abi_version*/, const void** /*error_category*/, + void* /*error_message*/, void** /*tracer_factory*/) { + return -1; +} + +OPENTRACING_DECLARE_IMPL_FACTORY(OpenTracingMakeTracerFactoryFct); diff --git a/src/jaegertracing/opentracing-cpp/test/tracer_test.cpp b/src/jaegertracing/opentracing-cpp/test/tracer_test.cpp new file mode 100644 index 000000000..eca3a367f --- /dev/null +++ b/src/jaegertracing/opentracing-cpp/test/tracer_test.cpp @@ -0,0 +1,43 @@ +#include <opentracing/ext/tags.h> +#include <opentracing/noop.h> +#include <opentracing/tracer.h> +using namespace opentracing; + +#define CATCH_CONFIG_MAIN +#include <opentracing/catch2/catch.hpp> + +TEST_CASE("tracer") { + auto tracer = MakeNoopTracer(); + + auto span1 = tracer->StartSpan("a"); + CHECK(span1); + + SECTION("Spans provide references to the tracer that created them.") { + CHECK(&span1->tracer() == tracer.get()); + } + + SECTION("Ensure basic operations compile.") { + auto span2 = tracer->StartSpan("b", {ChildOf(&span1->context())}); + CHECK(span2); + span2->SetOperationName("b1"); + span2->SetTag("x", true); + span2->SetTag(opentracing::ext::span_kind, + opentracing::ext::span_kind_rpc_client); + CHECK(span2->BaggageItem("y").empty()); + span2->Log({{"event", "xyz"}, {"abc", 123}}); + span2->Finish(); + } + + SECTION("A reference to a null SpanContext is ignored.") { + StartSpanOptions options; + ChildOf(nullptr).Apply(options); + CHECK(options.references.size() == 0); + } +} + +TEST_CASE("A tracer can be globally registered") { + CHECK(!Tracer::IsGlobalTracerRegistered()); + auto tracer = MakeNoopTracer(); + CHECK(Tracer::InitGlobal(tracer) != nullptr); + CHECK(Tracer::IsGlobalTracerRegistered()); +} diff --git a/src/jaegertracing/opentracing-cpp/test/util_test.cpp b/src/jaegertracing/opentracing-cpp/test/util_test.cpp new file mode 100644 index 000000000..9c1e30d02 --- /dev/null +++ b/src/jaegertracing/opentracing-cpp/test/util_test.cpp @@ -0,0 +1,26 @@ +#include <opentracing/util.h> +#include <cmath> +#include <cstdlib> // Work around to https://stackoverflow.com/a/30084734. +using namespace opentracing; + +#define CATCH_CONFIG_MAIN +#include <opentracing/catch2/catch.hpp> + +TEST_CASE("convert_time_point") { + SECTION("We can convert between time points of different clocks") { + // Check that converting from a system_clock time_point to a steady_clock + // time point and then back again produces approximately the same + // system_clock time_point. + auto t1 = SystemClock::now(); + auto t2 = convert_time_point<SteadyClock>(t1); + auto t3 = convert_time_point<SystemClock>(t2); + auto difference = std::abs( + std::chrono::duration_cast<std::chrono::microseconds>(t3 - t1).count()); + CHECK(difference < 100); + } + + SECTION("Converting times from the same clock gives the identity") { + auto t = SystemClock::now(); + CHECK(t == convert_time_point<SystemClock>(t)); + } +} diff --git a/src/jaegertracing/opentracing-cpp/test/value_test.cpp b/src/jaegertracing/opentracing-cpp/test/value_test.cpp new file mode 100644 index 000000000..cd84165d0 --- /dev/null +++ b/src/jaegertracing/opentracing-cpp/test/value_test.cpp @@ -0,0 +1,62 @@ +#include <opentracing/value.h> +using namespace opentracing; + +#define CATCH_CONFIG_MAIN +#include <opentracing/catch2/catch.hpp> + +TEST_CASE("Value") { + SECTION("Signed integers get converted to int64_t.") { + Value v1(123); + CHECK(v1.is<int64_t>()); + + Value v2(static_cast<short>(123)); + CHECK(v2.is<int64_t>()); + } + + SECTION("Unsigned integers get converted to uint64_t.") { + Value v1(123u); + CHECK(v1.is<uint64_t>()); + + Value v2(static_cast<unsigned short>(123)); + CHECK(v2.is<uint64_t>()); + } + + SECTION("Bool values are deduced as bool.") { + Value v1(true); + // Workaround for "disabled expansion of recursive macro" warning. + const auto is_bool = v1.is<bool>(); + CHECK(is_bool); + } + + SECTION("Floating point numbers are converted to double.") { + Value v1(1.0); + CHECK(v1.is<double>()); + Value v2(1.0f); + CHECK(v2.is<double>()); + } + + SECTION("std::string values are deduced as std::string.") { + Value v1(std::string("abc")); + CHECK(v1.is<std::string>()); + } + + SECTION("c-string values are deduced as c-strings.") { + Value v1("abc"); + CHECK(v1.is<const char*>()); + } + + SECTION("Complex values are permitted.") { + Value v1(Values{Value(1), Value(2)}); + (void)v1; + + Value v2(Dictionary{{"abc", Value(123)}}); + (void)v2; + } + + SECTION("Value types can be compared for equality.") { + Value v1{1}, v2{2}, v3{1.0}; + CHECK(v1 == v1); + CHECK(v1 != v2); + CHECK(v1 != v3); + } +} |