[ceph.git] / ceph / src / jaegertracing / opentelemetry-cpp / api / test / _metrics / noop_instrument_test.cc

// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0

#ifdef ENABLE_METRICS_PREVIEW
#  include <gtest/gtest.h>
#  include <cstring>
#  include <map>
#  include <string>

#  include "opentelemetry/_metrics/noop.h"

OPENTELEMETRY_BEGIN_NAMESPACE
namespace metrics
{

void noopIntCallback(ObserverResult<int> result)
{
  std::map<std::string, std::string> labels = {{"key", "value"}};
  auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
  result.observe(1, labelkv);
  result.observe(-1, labelkv);
}

void noopDoubleCallback(ObserverResult<double> result)
{
  std::map<std::string, std::string> labels = {{"key", "value"}};
  auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
  result.observe(1.5, labelkv);
  result.observe(-1.5, labelkv);
}

TEST(ValueObserver, Observe)
{
  NoopValueObserver<int> alpha("test", "none", "unitless", true, &noopIntCallback);

  NoopValueObserver<double> beta("test", "none", "unitless", true, &noopDoubleCallback);

  std::map<std::string, std::string> labels = {{"key", "value"}};
  auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};

  alpha.observe(1, labelkv);
  beta.observe(1.5, labelkv);
}

TEST(SumObserver, DefaultConstruction)
{
  NoopSumObserver<int> alpha("test", "none", "unitless", true, &noopIntCallback);

  NoopSumObserver<double> beta("test", "none", "unitless", true, &noopDoubleCallback);

  std::map<std::string, std::string> labels = {{"key", "value"}};
  auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};

  alpha.observe(1, labelkv);
  beta.observe(1.5, labelkv);
}

TEST(UpDownSumObserver, DefaultConstruction)
{
  NoopUpDownSumObserver<int> alpha("test", "none", "unitless", true, &noopIntCallback);

  NoopUpDownSumObserver<double> beta("test", "none", "unitless", true, &noopDoubleCallback);

  std::map<std::string, std::string> labels = {{"key", "value"}};
  auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};

  alpha.observe(1, labelkv);
  beta.observe(1.0, labelkv);
  alpha.observe(-1, labelkv);
  beta.observe(-1.0, labelkv);
}

TEST(Counter, DefaultConstruction)
{
  NoopCounter<int> alpha("test", "none", "unitless", true);
  NoopCounter<double> beta("other", "none", "unitless", true);

  std::map<std::string, std::string> labels = {{"key", "value"}};
  auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};

  alpha.bind(labelkv);

  auto gamma = alpha.bindNoopCounter(labelkv);
  auto delta = beta.bindNoopCounter(labelkv);

  gamma->unbind();
  delta->unbind();
}

TEST(Counter, Add)
{
  NoopCounter<int> alpha("test", "none", "unitless", true);
  NoopCounter<double> beta("other", "none", "unitless", true);

  std::map<std::string, std::string> labels = {{"key", "value"}};
  auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};

  alpha.add(1, labelkv);
  beta.add(1.5, labelkv);

  auto gamma = alpha.bindNoopCounter(labelkv);
  auto delta = beta.bindNoopCounter(labelkv);

  gamma->add(1);
  delta->add(1.5);

  gamma->unbind();
  delta->unbind();
}

TEST(UpDownCounter, DefaultConstruction)
{
  NoopUpDownCounter<int> alpha("test", "none", "unitless", true);
  NoopUpDownCounter<double> beta("other", "none", "unitless", true);

  std::map<std::string, std::string> labels = {{"key", "value"}};
  auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};

  alpha.bind(labelkv);

  auto gamma = alpha.bindNoopUpDownCounter(labelkv);
  auto delta = beta.bindNoopUpDownCounter(labelkv);

  gamma->unbind();
  delta->unbind();
}

TEST(UpDownCounter, Add)
{
  NoopUpDownCounter<int> alpha("test", "none", "unitless", true);
  NoopUpDownCounter<double> beta("other", "none", "unitless", true);

  std::map<std::string, std::string> labels = {{"key", "value"}};
  auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};

  alpha.add(1, labelkv);
  beta.add(1.5, labelkv);

  auto gamma = alpha.bindNoopUpDownCounter(labelkv);
  auto delta = beta.bindNoopUpDownCounter(labelkv);

  gamma->add(1);
  delta->add(1.0);
  gamma->add(-1);
  delta->add(-1.0);

  gamma->unbind();
  delta->unbind();
}

TEST(ValueRecorder, DefaultConstruction)
{
  NoopValueRecorder<int> alpha("test", "none", "unitless", true);
  NoopValueRecorder<double> beta("other", "none", "unitless", true);

  std::map<std::string, std::string> labels = {{"key", "value"}};
  auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};

  alpha.bind(labelkv);

  auto gamma = alpha.bindNoopValueRecorder(labelkv);
  auto delta = beta.bindNoopValueRecorder(labelkv);

  gamma->unbind();
  delta->unbind();
}

TEST(ValueRecorder, Record)
{
  NoopValueRecorder<int> alpha("test", "none", "unitless", true);
  NoopValueRecorder<double> beta("other", "none", "unitless", true);

  std::map<std::string, std::string> labels = {{"key", "value"}};
  auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};

  alpha.record(1, labelkv);
  beta.record(1.5, labelkv);

  auto gamma = alpha.bindNoopValueRecorder(labelkv);
  auto delta = beta.bindNoopValueRecorder(labelkv);

  gamma->record(1);
  delta->record(1.5);

  gamma->unbind();
  delta->unbind();
}

}  // namespace metrics
OPENTELEMETRY_END_NAMESPACE
#endif
Commit	Line	Data
1e59de90 TL	1	// Copyright The OpenTelemetry Authors
	2	// SPDX-License-Identifier: Apache-2.0
	3
	4	#ifdef ENABLE_METRICS_PREVIEW
	5	# include <gtest/gtest.h>
	6	# include <cstring>
	7	# include <map>
	8	# include <string>
	9
	10	# include "opentelemetry/_metrics/noop.h"
	11
	12	OPENTELEMETRY_BEGIN_NAMESPACE
	13	namespace metrics
	14	{
	15
	16	void noopIntCallback(ObserverResult<int> result)
	17	{
	18	std::map<std::string, std::string> labels = {{"key", "value"}};
	19	auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
	20	result.observe(1, labelkv);
	21	result.observe(-1, labelkv);
	22	}
	23
	24	void noopDoubleCallback(ObserverResult<double> result)
	25	{
	26	std::map<std::string, std::string> labels = {{"key", "value"}};
	27	auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
	28	result.observe(1.5, labelkv);
	29	result.observe(-1.5, labelkv);
	30	}
	31
	32	TEST(ValueObserver, Observe)
	33	{
	34	NoopValueObserver<int> alpha("test", "none", "unitless", true, &noopIntCallback);
	35
	36	NoopValueObserver<double> beta("test", "none", "unitless", true, &noopDoubleCallback);
	37
	38	std::map<std::string, std::string> labels = {{"key", "value"}};
	39	auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
	40
	41	alpha.observe(1, labelkv);
	42	beta.observe(1.5, labelkv);
	43	}
	44
	45	TEST(SumObserver, DefaultConstruction)
	46	{
	47	NoopSumObserver<int> alpha("test", "none", "unitless", true, &noopIntCallback);
	48
	49	NoopSumObserver<double> beta("test", "none", "unitless", true, &noopDoubleCallback);
	50
	51	std::map<std::string, std::string> labels = {{"key", "value"}};
	52	auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
	53
	54	alpha.observe(1, labelkv);
	55	beta.observe(1.5, labelkv);
	56	}
	57
	58	TEST(UpDownSumObserver, DefaultConstruction)
	59	{
	60	NoopUpDownSumObserver<int> alpha("test", "none", "unitless", true, &noopIntCallback);
	61
	62	NoopUpDownSumObserver<double> beta("test", "none", "unitless", true, &noopDoubleCallback);
	63
	64	std::map<std::string, std::string> labels = {{"key", "value"}};
65	auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
66
67	alpha.observe(1, labelkv);
68	beta.observe(1.0, labelkv);
69	alpha.observe(-1, labelkv);
70	beta.observe(-1.0, labelkv);
71	}
72
73	TEST(Counter, DefaultConstruction)
74	{
75	NoopCounter<int> alpha("test", "none", "unitless", true);
76	NoopCounter<double> beta("other", "none", "unitless", true);
77
78	std::map<std::string, std::string> labels = {{"key", "value"}};
79	auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
80
81	alpha.bind(labelkv);
82
83	auto gamma = alpha.bindNoopCounter(labelkv);
84	auto delta = beta.bindNoopCounter(labelkv);
85
86	gamma->unbind();
87	delta->unbind();
88	}
89
90	TEST(Counter, Add)
91	{
92	NoopCounter<int> alpha("test", "none", "unitless", true);
93	NoopCounter<double> beta("other", "none", "unitless", true);
94
95	std::map<std::string, std::string> labels = {{"key", "value"}};
96	auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
97
98	alpha.add(1, labelkv);
99	beta.add(1.5, labelkv);
100
101	auto gamma = alpha.bindNoopCounter(labelkv);
102	auto delta = beta.bindNoopCounter(labelkv);
103
104	gamma->add(1);
105	delta->add(1.5);
106
107	gamma->unbind();
108	delta->unbind();
109	}
110
111	TEST(UpDownCounter, DefaultConstruction)
112	{
113	NoopUpDownCounter<int> alpha("test", "none", "unitless", true);
114	NoopUpDownCounter<double> beta("other", "none", "unitless", true);
115
116	std::map<std::string, std::string> labels = {{"key", "value"}};
117	auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
118
119	alpha.bind(labelkv);
120
121	auto gamma = alpha.bindNoopUpDownCounter(labelkv);
122	auto delta = beta.bindNoopUpDownCounter(labelkv);
123
124	gamma->unbind();
125	delta->unbind();
126	}
127
128	TEST(UpDownCounter, Add)
129	{
130	NoopUpDownCounter<int> alpha("test", "none", "unitless", true);
131	NoopUpDownCounter<double> beta("other", "none", "unitless", true);
132
133	std::map<std::string, std::string> labels = {{"key", "value"}};
134	auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
135
136	alpha.add(1, labelkv);
137	beta.add(1.5, labelkv);
138
139	auto gamma = alpha.bindNoopUpDownCounter(labelkv);
140	auto delta = beta.bindNoopUpDownCounter(labelkv);
141
142	gamma->add(1);
143	delta->add(1.0);
144	gamma->add(-1);
145	delta->add(-1.0);
146
147	gamma->unbind();
148	delta->unbind();
149	}
150
151	TEST(ValueRecorder, DefaultConstruction)
152	{
153	NoopValueRecorder<int> alpha("test", "none", "unitless", true);
154	NoopValueRecorder<double> beta("other", "none", "unitless", true);
155
156	std::map<std::string, std::string> labels = {{"key", "value"}};
157	auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
158
159	alpha.bind(labelkv);
160
161	auto gamma = alpha.bindNoopValueRecorder(labelkv);
162	auto delta = beta.bindNoopValueRecorder(labelkv);
163
164	gamma->unbind();
165	delta->unbind();
166	}
167
168	TEST(ValueRecorder, Record)
169	{
170	NoopValueRecorder<int> alpha("test", "none", "unitless", true);
171	NoopValueRecorder<double> beta("other", "none", "unitless", true);
172
173	std::map<std::string, std::string> labels = {{"key", "value"}};
174	auto labelkv = common::KeyValueIterableView<decltype(labels)>{labels};
175
176	alpha.record(1, labelkv);
177	beta.record(1.5, labelkv);
178
179	auto gamma = alpha.bindNoopValueRecorder(labelkv);
180	auto delta = beta.bindNoopValueRecorder(labelkv);
181
182	gamma->record(1);
183	delta->record(1.5);
184
185	gamma->unbind();
186	delta->unbind();
187	}
188
189	} // namespace metrics
190	OPENTELEMETRY_END_NAMESPACE
191	#endif