widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixes widevine metrics proto serialization

Browse Source 
Changes to a much more efficient and more reusable protobuf format for
metrics.

Test: Widevine tests, Google Play and MediaDrm CTS test.
Bug: 73724218

Change-Id: I3299051d7a16bcd7758c8f272415ca40e10c1313
This commit is contained in:
Adam Stone
2018-02-20 19:12:02 -08:00
parent efc008c5a1
commit b19f0d106f
25 changed files with 1587 additions and 1867 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
libwvdrmengine/cdm/metrics/test/counter_metric_unittest.cpp
View File

@@ -6,171 +6,123 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "metric_serialization.h"
#include "scoped_ptr.h"
#include "string_conversions.h"
using drm_metrics::TestMetrics;
using testing::IsNull;
using testing::NotNull;
namespace wvcdm {
namespace metrics {
class MockCounterMetricSerializer : public MetricSerializer {
public:
MOCK_METHOD2(SetString, void(const std::string& metric_id,
const std::string& value));
MOCK_METHOD2(SetInt32, void(const std::string& metric_id,
int32_t value));
MOCK_METHOD2(SetInt64, void(const std::string& metric_id,
int64_t value));
MOCK_METHOD2(SetDouble, void(const std::string& metric_id,
double value));
};
TEST(CounterMetricTest, NoFieldsEmpty) {
wvcdm::metrics::CounterMetric<> metric;
class CounterMetricTest : public ::testing::Test {
public:
void SetUp() {
mock_serializer_.reset(new MockCounterMetricSerializer());
}
protected:
template<typename F1,
typename F2,
typename F3,
typename F4>
const std::map<std::string, int64_t>
GetValueMap(
const wvcdm::metrics::CounterMetric<F1, F2, F3, F4>&
metric) {
return metric.value_map_;
}
TestMetrics metric_proto;
metric.ToProto(metric_proto.mutable_test_counters());
ASSERT_EQ(0, metric_proto.test_counters().size());
}
scoped_ptr<MockCounterMetricSerializer> mock_serializer_;
};
TEST_F(CounterMetricTest, NoFieldsSuccessNullCallback) {
wvcdm::metrics::CounterMetric<> metric("no/fields/metric");
TEST(CounterMetricTest, NoFieldsSuccess) {
wvcdm::metrics::CounterMetric<> metric;
metric.Increment();
metric.Increment(10);
std::map<std::string, int64_t> value_map = GetValueMap(metric);
ASSERT_EQ(1u, GetValueMap(metric).size());
EXPECT_EQ(11, value_map.begin()->second);
EXPECT_EQ("", value_map.begin()->first);
TestMetrics metric_proto;
std::string serialized_metrics;
metric.ToProto(metric_proto.mutable_test_counters());
ASSERT_EQ(1, metric_proto.test_counters().size());
ASSERT_TRUE(metric_proto.SerializeToString(&serialized_metrics));
EXPECT_EQ(11, metric_proto.test_counters(0).count());
EXPECT_FALSE(metric_proto.test_counters(0).has_attributes())
<< std::string("Unexpected attributes value. Serialized metrics: ")
<< wvcdm::b2a_hex(serialized_metrics);
}
TEST_F(CounterMetricTest, NoFieldsSuccessWithCallback) {
wvcdm::metrics::CounterMetric<> metric("no/fields/metric");
EXPECT_CALL(*mock_serializer_,
SetInt64("no/fields/metric/count", 11));
metric.Increment();
metric.Increment(10);
metric.Serialize(mock_serializer_.get());
std::map<std::string, int64_t> value_map = GetValueMap(metric);
ASSERT_EQ(1u, GetValueMap(metric).size());
EXPECT_EQ(11, value_map.begin()->second);
EXPECT_EQ("", value_map.begin()->first);
}
TEST_F(CounterMetricTest, NoFieldsSuccessSingleIncrementWithCallback) {
wvcdm::metrics::CounterMetric<> metric("no/fields/metric");
EXPECT_CALL(*mock_serializer_,
SetInt64("no/fields/metric/count", 1));
metric.Increment();
metric.Serialize(mock_serializer_.get());
std::map<std::string, int64_t> value_map = GetValueMap(metric);
ASSERT_EQ(1u, GetValueMap(metric).size());
EXPECT_EQ(1, value_map.begin()->second);
EXPECT_EQ("", value_map.begin()->first);
}
TEST_F(CounterMetricTest, OneFieldSuccessNoCallback) {
wvcdm::metrics::CounterMetric<int> metric(
"single/fields/metric",
"error_code");
TEST(CounterMetricTest, OneFieldSuccess) {
wvcdm::metrics::CounterMetric<drm_metrics::Attributes::kErrorCodeFieldNumber,
int> metric;
metric.Increment(7);
metric.Increment(10, 7);
metric.Increment(13);
metric.Increment(20, 13);
std::map<std::string, int64_t> value_map = GetValueMap(metric);
ASSERT_EQ(2u, GetValueMap(metric).size());
// Verify both instances.
EXPECT_EQ(11, value_map["{error_code:7}"]);
EXPECT_EQ(21, value_map["{error_code:13}"]);
TestMetrics metric_proto;
metric.ToProto(metric_proto.mutable_test_counters());
ASSERT_EQ(2, metric_proto.test_counters().size());
EXPECT_EQ(11u, metric_proto.test_counters(0).count());
EXPECT_EQ(7, metric_proto.test_counters(0).attributes().error_code());
EXPECT_EQ(21, metric_proto.test_counters(1).count());
EXPECT_EQ(13, metric_proto.test_counters(1).attributes().error_code());
}
TEST_F(CounterMetricTest, TwoFieldsSuccess) {
wvcdm::metrics::CounterMetric<int, int> metric(
"two/fields/metric",
"error_code",
"size");
metric.Increment(7, 23);
metric.Increment(2, 7, 29);
metric.Increment(3, 11, 23);
metric.Increment(4, 11, 29);
metric.Increment(5, 7, 23);
metric.Increment(-5, 7, 29);
TEST(CounterMetricTest, TwoFieldsSuccess) {
CounterMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int,
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket> metric;
std::map<std::string, int64_t> value_map = GetValueMap(metric);
ASSERT_EQ(4u, GetValueMap(metric).size());
metric.Increment(7, Pow2Bucket(23)); // Increment by one.
metric.Increment(2, 7, Pow2Bucket(33));
metric.Increment(3, 11, Pow2Bucket(23));
metric.Increment(4, 11, Pow2Bucket(33));
metric.Increment(5, 7, Pow2Bucket(23));
metric.Increment(-5, 7, Pow2Bucket(33));
// Verify all instances.
EXPECT_EQ(6, value_map["{error_code:7&size:23}"]);
EXPECT_EQ(-3, value_map["{error_code:7&size:29}"]);
EXPECT_EQ(3, value_map["{error_code:11&size:23}"]);
EXPECT_EQ(4, value_map["{error_code:11&size:29}"]);
TestMetrics metric_proto;
metric.ToProto(metric_proto.mutable_test_counters());
ASSERT_EQ(4, metric_proto.test_counters().size());
// Verify that a non-existent distribution returns default 0
EXPECT_EQ(0, value_map["error_code:1,size:1"]);
EXPECT_EQ(6, metric_proto.test_counters(0).count());
EXPECT_EQ(7, metric_proto.test_counters(0).attributes().error_code());
EXPECT_EQ(16u, metric_proto.test_counters(0).attributes().length());
EXPECT_EQ(-3, metric_proto.test_counters(1).count());
EXPECT_EQ(7, metric_proto.test_counters(1).attributes().error_code());
EXPECT_EQ(32u, metric_proto.test_counters(1).attributes().length());
EXPECT_EQ(3, metric_proto.test_counters(2).count());
EXPECT_EQ(11, metric_proto.test_counters(2).attributes().error_code());
EXPECT_EQ(16u, metric_proto.test_counters(2).attributes().length());
EXPECT_EQ(4, metric_proto.test_counters(3).count());
EXPECT_EQ(11, metric_proto.test_counters(3).attributes().error_code());
EXPECT_EQ(32u, metric_proto.test_counters(3).attributes().length());
}
TEST_F(CounterMetricTest, TwoFieldsSuccessWithCallback) {
wvcdm::metrics::CounterMetric<int, std::string> metric("two/fields/metric",
"error_code",
"stringval");
TEST(CounterMetricTest, ThreeFieldsSuccess) {
CounterMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int,
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket,
drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool>
metric;
metric.Increment(7, Pow2Bucket(13), true);
EXPECT_CALL(
*mock_serializer_,
SetInt64("two/fields/metric/count{error_code:11&stringval:foo}", 5));
metric.Increment(11, "foo");
metric.Increment(4, 11, "foo");
metric.Serialize(mock_serializer_.get());
TestMetrics metric_proto;
metric.ToProto(metric_proto.mutable_test_counters());
ASSERT_EQ(1, metric_proto.test_counters().size());
EXPECT_EQ(1, metric_proto.test_counters(0).count());
EXPECT_EQ(7, metric_proto.test_counters(0).attributes().error_code());
EXPECT_EQ(8u, metric_proto.test_counters(0).attributes().length());
EXPECT_TRUE(metric_proto.test_counters(0).attributes().error_code_bool());
}
TEST_F(CounterMetricTest, ThreeFieldsSuccess) {
wvcdm::metrics::CounterMetric<int, int, bool> metric(
"three/fields/metric",
"error_code",
"size",
"woke up happy");
metric.Increment(7, 13, false);
TEST(CounterMetricTest, FourFieldsSuccess) {
CounterMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int,
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket,
drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool,
drm_metrics::Attributes::kSecurityLevelFieldNumber,
SecurityLevel> metric;
metric.Increment(10LL, 7, Pow2Bucket(13), true, kLevel3);
std::map<std::string, int64_t> value_map = GetValueMap(metric);
ASSERT_EQ(1u, GetValueMap(metric).size());
EXPECT_EQ("{error_code:7&size:13&woke up happy:0}",
value_map.begin()->first);
EXPECT_EQ(1, value_map.begin()->second);
}
TEST_F(CounterMetricTest, FourFieldsSuccess) {
wvcdm::metrics::CounterMetric<int, int, bool, std::string> metric(
"Four/fields/metric",
"error_code",
"size",
"woke up happy",
"horoscope");
metric.Increment(10LL, 7, 13, true, "find your true love");
std::map<std::string, int64_t> value_map = GetValueMap(metric);
ASSERT_EQ(1u, GetValueMap(metric).size());
EXPECT_EQ(
"{error_code:7&size:13&woke up happy:1&horoscope:find your true love}",
value_map.begin()->first);
EXPECT_EQ(10, value_map.begin()->second);
TestMetrics metric_proto;
metric.ToProto(metric_proto.mutable_test_counters());
ASSERT_EQ(1, metric_proto.test_counters().size());
EXPECT_EQ(10, metric_proto.test_counters(0).count());
EXPECT_EQ(7, metric_proto.test_counters(0).attributes().error_code());
EXPECT_EQ(8u, metric_proto.test_counters(0).attributes().length());
EXPECT_TRUE(metric_proto.test_counters(0).attributes().error_code_bool());
EXPECT_EQ(kLevel3,
metric_proto.test_counters(0).attributes().security_level());
}
} // namespace metrics

10
libwvdrmengine/cdm/metrics/test/distribution_unittest.cpp
View File

@@ -13,10 +13,10 @@ namespace metrics {
TEST(DistributionTest, NoValuesRecorded) {
Distribution distribution;
EXPECT_EQ(DBL_MAX, distribution.Min());
EXPECT_EQ(-DBL_MAX, distribution.Max());
EXPECT_EQ(FLT_MAX, distribution.Min());
EXPECT_EQ(-FLT_MAX, distribution.Max());
EXPECT_EQ(0, distribution.Mean());
EXPECT_EQ(0, distribution.Count());
EXPECT_EQ(0u, distribution.Count());
EXPECT_EQ(0, distribution.Variance());
}
@@ -26,7 +26,7 @@ TEST(DistributionTest, OneValueRecorded) {
EXPECT_EQ(5, distribution.Min());
EXPECT_EQ(5, distribution.Max());
EXPECT_EQ(5, distribution.Mean());
EXPECT_EQ(1, distribution.Count());
EXPECT_EQ(1u, distribution.Count());
EXPECT_EQ(0, distribution.Variance());
}
@@ -38,7 +38,7 @@ TEST(DistributionTest, MultipleValuesRecorded) {
EXPECT_EQ(5, distribution.Min());
EXPECT_EQ(15, distribution.Max());
EXPECT_EQ(10, distribution.Mean());
EXPECT_EQ(3, distribution.Count());
EXPECT_EQ(3u, distribution.Count());
EXPECT_NEAR(16.6667, distribution.Variance(), 0.0001);
}

276
libwvdrmengine/cdm/metrics/test/event_metric_unittest.cpp
View File

@@ -3,213 +3,165 @@
// Unit tests for EventMetric
#include "event_metric.h"
#include "metric_serialization.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "scoped_ptr.h"
#include "string_conversions.h"
using drm_metrics::TestMetrics;
using testing::IsNull;
using testing::NotNull;
namespace wvcdm {
namespace metrics {
class MockEventMetricSerializer : public MetricSerializer {
public:
MOCK_METHOD2(SetString, void(const std::string& metric_id,
const std::string& value));
MOCK_METHOD2(SetInt32, void(const std::string& metric_id,
int32_t value));
MOCK_METHOD2(SetInt64, void(const std::string& metric_id,
int64_t value));
MOCK_METHOD2(SetDouble, void(const std::string& metric_id,
double value));
};
class EventMetricTest : public ::testing::Test {
public:
void SetUp() {
mock_serializer_.reset(new MockEventMetricSerializer());
}
protected:
template<typename F1,
typename F2,
typename F3,
typename F4>
const std::map<std::string, Distribution*>
GetValueMap(
const wvcdm::metrics::EventMetric<F1, F2, F3, F4>&
metric) {
return metric.value_map_;
}
void SetUp() {}
scoped_ptr<MockEventMetricSerializer> mock_serializer_;
protected:
};
TEST_F(EventMetricTest, NoFieldsSuccessNullCallback) {
wvcdm::metrics::EventMetric<> metric("no/fields/metric");
TEST_F(EventMetricTest, NoFieldsEmpty) {
wvcdm::metrics::EventMetric<> metric;
TestMetrics metric_proto;
metric.ToProto(metric_proto.mutable_test_distributions());
ASSERT_EQ(0, metric_proto.test_distributions().size());
}
TEST_F(EventMetricTest, NoFieldsSuccess) {
wvcdm::metrics::EventMetric<> metric;
metric.Record(10LL);
metric.Record(10LL);
std::map<std::string, Distribution*> value_map = GetValueMap(metric);
ASSERT_EQ(1u, GetValueMap(metric).size());
EXPECT_EQ(2, value_map.begin()->second->Count());
EXPECT_EQ("", value_map.begin()->first);
TestMetrics metric_proto;
metric.ToProto(metric_proto.mutable_test_distributions());
std::string serialized_metrics;
ASSERT_TRUE(metric_proto.SerializeToString(&serialized_metrics));
ASSERT_EQ(1, metric_proto.test_distributions().size());
EXPECT_EQ(2u, metric_proto.test_distributions(0).operation_count());
EXPECT_FALSE(metric_proto.test_distributions(0).has_attributes())
<< std::string("Unexpected attributes value. Serialized metrics: ")
<< wvcdm::b2a_hex(serialized_metrics);
}
TEST_F(EventMetricTest, NoFieldsSuccessWithCallback) {
wvcdm::metrics::EventMetric<> metric("no/fields/metric");
EXPECT_CALL(*mock_serializer_,
SetInt64("no/fields/metric/count", 2));
EXPECT_CALL(*mock_serializer_,
SetDouble("no/fields/metric/mean", 10.0));
EXPECT_CALL(*mock_serializer_,
SetDouble("no/fields/metric/variance", 0.0));
EXPECT_CALL(*mock_serializer_,
SetDouble("no/fields/metric/min", 10.0));
EXPECT_CALL(*mock_serializer_,
SetDouble("no/fields/metric/max", 10.0));
metric.Record(10);
metric.Record(10);
metric.Serialize(mock_serializer_.get());
std::map<std::string, Distribution*> value_map = GetValueMap(metric);
ASSERT_EQ(1u, GetValueMap(metric).size());
EXPECT_EQ(2, value_map.begin()->second->Count());
EXPECT_EQ("", value_map.begin()->first);
}
TEST_F(EventMetricTest, NoFieldsSuccessSingleRecordWithCallback) {
wvcdm::metrics::EventMetric<> metric("no/fields/metric");
EXPECT_CALL(*mock_serializer_,
SetInt64("no/fields/metric/count", 1.0));
EXPECT_CALL(*mock_serializer_,
SetDouble("no/fields/metric/mean", 10.0));
metric.Record(10);
metric.Serialize(mock_serializer_.get());
std::map<std::string, Distribution*> value_map = GetValueMap(metric);
ASSERT_EQ(1u, GetValueMap(metric).size());
EXPECT_EQ(1, value_map.begin()->second->Count());
EXPECT_EQ("", value_map.begin()->first);
}
TEST_F(EventMetricTest, OneFieldSuccessNoCallback) {
wvcdm::metrics::EventMetric<int> metric(
"single/fields/metric",
"error_code");
TEST_F(EventMetricTest, OneFieldSuccess) {
EventMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int> metric;
metric.Record(10LL, 7);
metric.Record(11LL, 13);
metric.Record(12LL, 13);
std::map<std::string, Distribution*> value_map = GetValueMap(metric);
ASSERT_EQ(2u, GetValueMap(metric).size());
// Verify both instances.
// TODO(blueeyes): Export MakeFieldNameString so it can be used here.
Distribution* distribution_error_7 = value_map["{error_code:7}"];
Distribution* distribution_error_13 = value_map["{error_code:13}"];
ASSERT_THAT(distribution_error_7, NotNull());
ASSERT_THAT(distribution_error_13, NotNull());
TestMetrics metric_proto;
metric.ToProto(metric_proto.mutable_test_distributions());
ASSERT_EQ(2, metric_proto.test_distributions().size());
EXPECT_EQ(1, distribution_error_7->Count());
EXPECT_EQ(2, distribution_error_13->Count());
EXPECT_EQ(1u, metric_proto.test_distributions(0).operation_count());
EXPECT_EQ(10LL, metric_proto.test_distributions(0).mean());
EXPECT_EQ(2u, metric_proto.test_distributions(1).operation_count());
EXPECT_NEAR(11.5, metric_proto.test_distributions(1).mean(), 1.0);
EXPECT_NEAR(0.5, metric_proto.test_distributions(1).variance(), 0.5);
EXPECT_EQ(11, metric_proto.test_distributions(1).min());
EXPECT_EQ(12, metric_proto.test_distributions(1).max());
}
TEST_F(EventMetricTest, TwoFieldsSuccess) {
wvcdm::metrics::EventMetric<int, int> metric(
"two/fields/metric",
"error_code",
"size");
metric.Record(1, 7, 23);
metric.Record(2, 7, 29);
metric.Record(3, 11, 23);
metric.Record(4, 11, 29);
metric.Record(5, 7, 23);
EventMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int,
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket> metric;
std::map<std::string, Distribution*> value_map = GetValueMap(metric);
ASSERT_EQ(4u, GetValueMap(metric).size());
metric.Record(1, 7, Pow2Bucket(23));
metric.Record(2, 7, Pow2Bucket(33));
metric.Record(3, 11, Pow2Bucket(23));
metric.Record(4, 11, Pow2Bucket(33));
metric.Record(5, 7, Pow2Bucket(23));
// Verify all instances.
Distribution* distribution_7_23 = value_map["{error_code:7&size:23}"];
Distribution* distribution_7_29 = value_map["{error_code:7&size:29}"];
Distribution* distribution_11_23 = value_map["{error_code:11&size:23}"];
Distribution* distribution_11_29 = value_map["{error_code:11&size:29}"];
ASSERT_THAT(distribution_7_23, NotNull());
ASSERT_THAT(distribution_7_29, NotNull());
ASSERT_THAT(distribution_11_23, NotNull());
ASSERT_THAT(distribution_11_29, NotNull());
TestMetrics metric_proto;
metric.ToProto(metric_proto.mutable_test_distributions());
ASSERT_EQ(4, metric_proto.test_distributions().size());
EXPECT_EQ(2, distribution_7_23->Count());
EXPECT_EQ(1, distribution_7_29->Count());
EXPECT_EQ(1, distribution_11_23->Count());
EXPECT_EQ(1, distribution_11_29->Count());
// error 7, bucket 16
EXPECT_EQ(2u, metric_proto.test_distributions(0).operation_count());
EXPECT_EQ(3LL, metric_proto.test_distributions(0).mean());
EXPECT_NEAR(3.5, metric_proto.test_distributions(0).variance(), 0.5);
EXPECT_EQ(1, metric_proto.test_distributions(0).min());
EXPECT_EQ(5, metric_proto.test_distributions(0).max());
EXPECT_EQ(7, metric_proto.test_distributions(0).attributes().error_code());
EXPECT_EQ(16U, metric_proto.test_distributions(0).attributes().length());
// Verify that a non-existent distribution returns nullptr.
Distribution* null_distribution = value_map["error_code:1,size:1"];
ASSERT_THAT(null_distribution, IsNull());
}
// error 7, bucket 32
EXPECT_EQ(1u, metric_proto.test_distributions(1).operation_count());
EXPECT_EQ(2, metric_proto.test_distributions(1).mean());
EXPECT_EQ(7, metric_proto.test_distributions(1).attributes().error_code());
EXPECT_EQ(32U, metric_proto.test_distributions(1).attributes().length());
TEST_F(EventMetricTest, TwoFieldsSuccessWithCallback) {
wvcdm::metrics::EventMetric<int, Pow2Bucket> metric("two/fields/metric",
"error_code",
"pow2_size");
// error 11, bucket 16
EXPECT_EQ(1u, metric_proto.test_distributions(2).operation_count());
EXPECT_EQ(3, metric_proto.test_distributions(2).mean());
EXPECT_EQ(11, metric_proto.test_distributions(2).attributes().error_code());
EXPECT_EQ(16U, metric_proto.test_distributions(2).attributes().length());
// Callbacks from second record operation.
EXPECT_CALL(
*mock_serializer_,
SetInt64("two/fields/metric/count{error_code:11&pow2_size:16}", 2.0));
EXPECT_CALL(
*mock_serializer_,
SetDouble("two/fields/metric/mean{error_code:11&pow2_size:16}", 3.5));
EXPECT_CALL(
*mock_serializer_,
SetDouble("two/fields/metric/variance{error_code:11&pow2_size:16}",
0.25));
EXPECT_CALL(
*mock_serializer_,
SetDouble("two/fields/metric/min{error_code:11&pow2_size:16}", 3.0));
EXPECT_CALL(
*mock_serializer_,
SetDouble("two/fields/metric/max{error_code:11&pow2_size:16}", 4.0));
metric.Record(3, 11, Pow2Bucket(29));
metric.Record(4, 11, Pow2Bucket(29));
metric.Serialize(mock_serializer_.get());
// error 11, bucket 32
EXPECT_EQ(1u, metric_proto.test_distributions(3).operation_count());
EXPECT_EQ(4, metric_proto.test_distributions(3).mean());
EXPECT_EQ(11, metric_proto.test_distributions(3).attributes().error_code());
EXPECT_EQ(32U, metric_proto.test_distributions(3).attributes().length());
}
TEST_F(EventMetricTest, ThreeFieldsSuccess) {
wvcdm::metrics::EventMetric<int, int, bool> metric(
"three/fields/metric",
"error_code",
"size",
"woke up happy");
metric.Record(10LL, 7, 13, false);
EventMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int,
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket,
drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool> metric;
metric.Record(10LL, 7, Pow2Bucket(13), false);
metric.Record(11LL, 8, Pow2Bucket(17), true);
TestMetrics metric_proto;
metric.ToProto(metric_proto.mutable_test_distributions());
ASSERT_EQ(2, metric_proto.test_distributions().size());
std::map<std::string, Distribution*> value_map = GetValueMap(metric);
ASSERT_EQ(1u, GetValueMap(metric).size());
EXPECT_EQ("{error_code:7&size:13&woke up happy:0}",
value_map.begin()->first);
EXPECT_EQ(1, value_map.begin()->second->Count());
EXPECT_EQ(1u, metric_proto.test_distributions(0).operation_count());
EXPECT_EQ(10LL, metric_proto.test_distributions(0).mean());
EXPECT_FALSE(metric_proto.test_distributions(0).has_variance());
EXPECT_EQ(7, metric_proto.test_distributions(0).attributes().error_code());
EXPECT_EQ(8u, metric_proto.test_distributions(0).attributes().length());
EXPECT_EQ(false,
metric_proto.test_distributions(0).attributes().error_code_bool());
EXPECT_EQ(1u, metric_proto.test_distributions(1).operation_count());
EXPECT_EQ(11LL, metric_proto.test_distributions(1).mean());
EXPECT_FALSE(metric_proto.test_distributions(1).has_variance());
EXPECT_EQ(8, metric_proto.test_distributions(1).attributes().error_code());
EXPECT_EQ(16u, metric_proto.test_distributions(1).attributes().length());
EXPECT_EQ(true,
metric_proto.test_distributions(1).attributes().error_code_bool());
}
TEST_F(EventMetricTest, FourFieldsSuccess) {
wvcdm::metrics::EventMetric<int, int, bool, std::string> metric(
"Four/fields/metric",
"error_code",
"size",
"woke up happy",
"horoscope");
metric.Record(10LL, 7, 13, true, "find your true love");
EventMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int,
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket,
drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool,
drm_metrics::Attributes::kCdmSecurityLevelFieldNumber,
CdmSecurityLevel> metric;
std::map<std::string, Distribution*> value_map = GetValueMap(metric);
ASSERT_EQ(1u, GetValueMap(metric).size());
metric.Record(10LL, 7, Pow2Bucket(13), true, kSecurityLevelL3);
TestMetrics metric_proto;
metric.ToProto(metric_proto.mutable_test_distributions());
ASSERT_EQ(1, metric_proto.test_distributions().size());
EXPECT_EQ(1u, metric_proto.test_distributions(0).operation_count());
EXPECT_EQ(10LL, metric_proto.test_distributions(0).mean());
EXPECT_FALSE(metric_proto.test_distributions(0).has_variance());
EXPECT_EQ(7, metric_proto.test_distributions(0).attributes().error_code());
EXPECT_EQ(8u, metric_proto.test_distributions(0).attributes().length());
EXPECT_EQ(true,
metric_proto.test_distributions(0).attributes().error_code_bool());
EXPECT_EQ(
"{error_code:7&size:13&woke up happy:1&horoscope:find your true love}",
value_map.begin()->first);
EXPECT_EQ(1, value_map.begin()->second->Count());
3u, metric_proto.test_distributions(0).attributes().cdm_security_level());
}
TEST_F(EventMetricTest, Pow2BucketTest) {

83
libwvdrmengine/cdm/metrics/test/value_metric_unittest.cpp
View File

@@ -8,70 +8,57 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "metric_serialization.h"
#include "metrics.pb.h"
#include "scoped_ptr.h"
namespace wvcdm {
namespace metrics {
class MockMetricSerializer : public MetricSerializer {
public:
MOCK_METHOD2(SetString, void(const std::string& metric_id,
const std::string& value));
MOCK_METHOD2(SetInt32, void(const std::string& metric_id,
int32_t value));
MOCK_METHOD2(SetInt64, void(const std::string& metric_id,
int64_t value));
MOCK_METHOD2(SetDouble, void(const std::string& metric_id,
double value));
};
TEST(ValueMetricTest, StringValue) {
ValueMetric<std::string> metric;
metric.Record("foo");
class ValueMetricTest : public ::testing::Test {
public:
void SetUp() {
mock_serializer_.reset(new MockMetricSerializer());
}
protected:
scoped_ptr<MockMetricSerializer> mock_serializer_;
};
TEST_F(ValueMetricTest, StringValue) {
ValueMetric<std::string> value_metric("string/metric");
value_metric.Record("foo");
EXPECT_CALL(*mock_serializer_,
SetString("string/metric", "foo"));
value_metric.Serialize(mock_serializer_.get());
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ("foo", metric_proto->string_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
TEST_F(ValueMetricTest, DoubleValue) {
ValueMetric<double> value_metric("double/metric");
value_metric.Record(42.0);
TEST(ValueMetricTest, DoubleValue) {
ValueMetric<double> metric;
metric.Record(42.0);
EXPECT_CALL(*mock_serializer_,
SetDouble("double/metric", 42.0));
value_metric.Serialize(mock_serializer_.get());
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(42.0, metric_proto->double_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
TEST_F(ValueMetricTest, Int32Value) {
ValueMetric<int32_t> value_metric("int32/metric");
value_metric.Record(42);
TEST(ValueMetricTest, Int32Value) {
ValueMetric<int32_t> metric;
metric.Record(42);
EXPECT_CALL(*mock_serializer_,
SetInt32("int32/metric", 42));
value_metric.Serialize(mock_serializer_.get());
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(42, metric_proto->int_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
TEST_F(ValueMetricTest, Int64Value) {
ValueMetric<int64_t> value_metric("int64/metric");
value_metric.Record(42);
TEST(ValueMetricTest, Int64Value) {
ValueMetric<int64_t> metric;
metric.Record(42);
EXPECT_CALL(*mock_serializer_,
SetInt64("int64/metric", 42));
value_metric.Serialize(mock_serializer_.get());
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(42, metric_proto->int_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
TEST(ValueMetricTest, SetError) {
ValueMetric<int64_t> metric;
metric.Record(42);
metric.SetError(7);
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(7, metric_proto->error_code());
ASSERT_FALSE(metric_proto->has_int_value());
}
} // namespace metrics
} // namespace wvcdm