1 files changed, 229 insertions, 0 deletions
diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/test/_metrics/exact_aggregator_test.cc b/src/jaegertracing/opentelemetry-cpp/sdk/test/_metrics/exact_aggregator_test.cc
new file mode 100644
index 000000000..443cb65ea
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/sdk/test/_metrics/exact_aggregator_test.cc
@@ -0,0 +1,229 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <gtest/gtest.h>
+
+#ifdef ENABLE_METRICS_PREVIEW
+#  include <thread>
+
+#  include "opentelemetry/sdk/_metrics/aggregator/exact_aggregator.h"
+
+using namespace opentelemetry::sdk::metrics;
+namespace metrics_api = opentelemetry::metrics;
+
+TEST(ExactAggregatorOrdered, Update)
+{
+  ExactAggregator<int> agg(metrics_api::InstrumentKind::Counter);
+
+  std::vector<int> correct;
+
+  ASSERT_EQ(agg.get_values(), correct);
+
+  agg.update(1);
+  correct.push_back(1);
+
+  ASSERT_EQ(agg.get_values(), std::vector<int>{1});
+
+  for (int i = 2; i <= 5; ++i)
+  {
+    correct.push_back(i);
+    agg.update(i);
+  }
+  ASSERT_EQ(agg.get_values(), correct);
+}
+
+TEST(ExactAggregatorOrdered, Checkpoint)
+{
+  ExactAggregator<int> agg(metrics_api::InstrumentKind::Counter);
+
+  std::vector<int> correct;
+
+  ASSERT_EQ(agg.get_checkpoint(), correct);
+
+  agg.update(1);
+  correct.push_back(1);
+  agg.checkpoint();
+
+  ASSERT_EQ(agg.get_checkpoint(), correct);
+}
+
+TEST(ExactAggregatorOrdered, Merge)
+{
+  ExactAggregator<int> agg1(metrics_api::InstrumentKind::Counter);
+  ExactAggregator<int> agg2(metrics_api::InstrumentKind::Counter);
+
+  agg1.update(1);
+  agg2.update(2);
+  agg1.merge(agg2);
+
+  std::vector<int> correct{1, 2};
+
+  ASSERT_EQ(agg1.get_values(), correct);
+}
+
+TEST(ExactAggregatorOrdered, BadMerge)
+{
+  // This verifies that we encounter and error when we try to merge
+  // two aggregators of different numeric types together.
+  ExactAggregator<int> agg1(metrics_api::InstrumentKind::Counter);
+  ExactAggregator<int> agg2(metrics_api::InstrumentKind::ValueRecorder);
+
+  agg1.update(1);
+  agg2.update(2);
+
+  agg1.merge(agg2);
+
+  // Verify that the aggregators did NOT merge
+  std::vector<int> correct{1};
+  ASSERT_EQ(agg1.get_values(), correct);
+}
+
+TEST(ExactAggregatorOrdered, Types)
+{
+  // This test verifies that we do not encounter any errors when
+  // using various numeric types.
+  ExactAggregator<int> agg_int(metrics_api::InstrumentKind::Counter);
+  ExactAggregator<long> agg_long(metrics_api::InstrumentKind::Counter);
+  ExactAggregator<float> agg_float(metrics_api::InstrumentKind::Counter);
+  ExactAggregator<double> agg_double(metrics_api::InstrumentKind::Counter);
+
+  for (int i = 1; i <= 5; ++i)
+  {
+    agg_int.update(i);
+    agg_long.update(i);
+  }
+
+  for (float i = 1.0; i <= 5.0; i += 1)
+  {
+    agg_float.update(i);
+    agg_double.update(i);
+  }
+
+  std::vector<int> correct_int{1, 2, 3, 4, 5};
+  std::vector<long> correct_long{1, 2, 3, 4, 5};
+  std::vector<float> correct_float{1.0, 2.0, 3.0, 4.0, 5.0};
+  std::vector<double> correct_double{1.0, 2.0, 3.0, 4.0, 5.0};
+
+  ASSERT_EQ(agg_int.get_values(), correct_int);
+  ASSERT_EQ(agg_long.get_values(), correct_long);
+  ASSERT_EQ(agg_float.get_values(), correct_float);
+  ASSERT_EQ(agg_double.get_values(), correct_double);
+}
+
+TEST(ExactAggregatorQuant, Update)
+{
+  ExactAggregator<int> agg(metrics_api::InstrumentKind::Counter, true);
+
+  std::vector<int> correct;
+
+  ASSERT_EQ(agg.get_values(), correct);
+
+  agg.update(1);
+  correct.push_back(1);
+
+  ASSERT_EQ(agg.get_values(), std::vector<int>{1});
+
+  for (int i = 2; i <= 5; ++i)
+  {
+    correct.push_back(i);
+    agg.update(i);
+  }
+  ASSERT_EQ(agg.get_values(), correct);
+}
+
+TEST(ExactAggregatorQuant, Checkpoint)
+{
+  // This test verifies that the aggregator updates correctly when
+  // quantile estimation is turned on.
+
+  ExactAggregator<int> agg(metrics_api::InstrumentKind::Counter, true);
+
+  std::vector<int> correct;
+
+  ASSERT_EQ(agg.get_checkpoint(), correct);
+
+  agg.update(1);
+  agg.update(0);
+  agg.update(-1);
+
+  // The vector MUST be sorted when checkpointed
+  correct.push_back(-1);
+  correct.push_back(0);
+  correct.push_back(1);
+  agg.checkpoint();
+
+  ASSERT_EQ(agg.get_checkpoint(), correct);
+}
+
+TEST(ExactAggregatorQuant, Quantile)
+{
+  // This test verifies that the quantile estimation function returns
+  // the correct values.
+
+  ExactAggregator<int> agg(metrics_api::InstrumentKind::Counter, true);
+
+  std::vector<int> tmp{3, 9, 42, 57, 163, 210, 272, 300};
+  for (int i : tmp)
+  {
+    agg.update(i);
+  }
+  agg.checkpoint();
+  ASSERT_EQ(agg.get_quantiles(.25), 42);
+  ASSERT_EQ(agg.get_quantiles(0.5), 163);
+  ASSERT_EQ(agg.get_quantiles(0.75), 272);
+}
+
+TEST(ExactAggregatorInOrder, Quantile)
+{
+  // This test verifies that if the user has an exact aggregator in "in-order" mode
+  // an exception will be thrown if they call the quantile() function.
+  ExactAggregator<int> agg(metrics_api::InstrumentKind::Counter);
+
+  std::vector<int> tmp{3, 9, 42, 57, 163, 210, 272, 300};
+  for (int i : tmp)
+  {
+    agg.update(i);
+  }
+  agg.checkpoint();
+#  if __EXCEPTIONS
+  ASSERT_THROW(agg.get_quantiles(0.5), std::domain_error);
+#  else
+#  endif
+}
+
+void callback(ExactAggregator<int> &agg)
+{
+  for (int i = 1; i <= 10000; ++i)
+  {
+    agg.update(i);
+  }
+}
+
+TEST(ExactAggregatorQuant, Concurrency)
+{
+  // This test checks that the aggregator updates appropriately
+  // when called in a multi-threaded context.
+  ExactAggregator<int> agg(metrics_api::InstrumentKind::Counter, true);
+
+  std::thread first(&callback, std::ref(agg));
+  std::thread second(&callback, std::ref(agg));
+
+  first.join();
+  second.join();
+
+  std::vector<int> correct;
+  for (int i = 1; i <= 10000; ++i)
+  {
+    correct.push_back(i);
+    correct.push_back(i);
+  }
+  agg.checkpoint();
+
+  ASSERT_EQ(agg.get_checkpoint(), correct);
+}
+#else
+TEST(ExactAggregatorQuant, DummyTest)
+{
+  // empty
+}
+#endif