1 /*
2 * Copyright 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "DrmMetricsTest"
18 #include "mediadrm/DrmMetrics.h"
19
20 #include <android/hardware/drm/1.0/types.h>
21 #include <android/hardware/drm/1.1/types.h>
22 #include <binder/PersistableBundle.h>
23 #include <google/protobuf/text_format.h>
24 #include <google/protobuf/util/message_differencer.h>
25 #include <gtest/gtest.h>
26 #include <utils/Log.h>
27
28 #include "protos/metrics.pb.h"
29
30 using ::android::drm_metrics::DrmFrameworkMetrics;
31 using ::android::hardware::hidl_vec;
32 using ::android::hardware::drm::V1_0::EventType;
33 using ::android::hardware::drm::V1_2::KeyStatusType;
34 using ::android::hardware::drm::V1_0::Status;
35 using ::android::hardware::drm::V1_1::DrmMetricGroup;
36 using ::android::os::PersistableBundle;
37 using ::google::protobuf::util::MessageDifferencer;
38 using ::google::protobuf::TextFormat;
39
40 namespace android {
41
42 /**
43 * Unit tests for the MediaDrmMetrics class.
44 */
45 class MediaDrmMetricsTest : public ::testing::Test {};
46
47 /**
48 * This derived class mocks the clock for testing purposes.
49 */
50 class FakeMediaDrmMetrics : public MediaDrmMetrics {
51 public:
FakeMediaDrmMetrics()52 FakeMediaDrmMetrics() : MediaDrmMetrics(), time_(0) {};
53
GetCurrentTimeMs()54 int64_t GetCurrentTimeMs() { return time_++; }
55 int64_t time_;
56 };
57
TEST_F(MediaDrmMetricsTest,EmptySuccess)58 TEST_F(MediaDrmMetricsTest, EmptySuccess) {
59 MediaDrmMetrics metrics;
60 PersistableBundle bundle;
61
62 metrics.Export(&bundle);
63 EXPECT_TRUE(bundle.empty());
64 }
65
TEST_F(MediaDrmMetricsTest,AllValuesSuccessCounts)66 TEST_F(MediaDrmMetricsTest, AllValuesSuccessCounts) {
67 MediaDrmMetrics metrics;
68
69 metrics.mOpenSessionCounter.Increment(OK);
70 metrics.mCloseSessionCounter.Increment(OK);
71
72 {
73 EventTimer<status_t> get_key_request_timer(&metrics.mGetKeyRequestTimeUs);
74 EventTimer<status_t> provide_key_response_timer(
75 &metrics.mProvideKeyResponseTimeUs);
76 get_key_request_timer.SetAttribute(OK);
77 provide_key_response_timer.SetAttribute(OK);
78 }
79
80 metrics.mGetProvisionRequestCounter.Increment(OK);
81 metrics.mProvideProvisionResponseCounter.Increment(OK);
82 metrics.mGetDeviceUniqueIdCounter.Increment(OK);
83
84 metrics.mKeyStatusChangeCounter.Increment(KeyStatusType::USABLE);
85 metrics.mEventCounter.Increment(EventType::PROVISION_REQUIRED);
86
87 PersistableBundle bundle;
88
89 metrics.Export(&bundle);
90 EXPECT_EQ(11U, bundle.size());
91
92 // Verify the list of pairs of int64 metrics.
93 std::vector<std::pair<std::string, int64_t>> expected_values = {
94 { "drm.mediadrm.open_session.ok.count", 1 },
95 { "drm.mediadrm.close_session.ok.count", 1 },
96 { "drm.mediadrm.get_key_request.ok.count", 1 },
97 { "drm.mediadrm.provide_key_response.ok.count", 1 },
98 { "drm.mediadrm.get_provision_request.ok.count", 1 },
99 { "drm.mediadrm.provide_provision_response.ok.count", 1 },
100 { "drm.mediadrm.key_status_change.USABLE.count", 1 },
101 { "drm.mediadrm.event.PROVISION_REQUIRED.count", 1 },
102 { "drm.mediadrm.get_device_unique_id.ok.count", 1 }};
103 for (const auto& expected_pair : expected_values) {
104 String16 key(expected_pair.first.c_str());
105 int64_t value = -1;
106 EXPECT_TRUE(bundle.getLong(key, &value))
107 << "Unexpected error retrieviing key: " << key;
108 EXPECT_EQ(expected_pair.second, value)
109 << "Unexpected value for " << expected_pair.first << ". " << value;
110 }
111
112 // Validate timing values exist.
113 String16 get_key_request_key(
114 "drm.mediadrm.get_key_request.ok.average_time_micros");
115 String16 provide_key_response_key(
116 "drm.mediadrm.provide_key_response.ok.average_time_micros");
117 int64_t value = -1;
118 EXPECT_TRUE(bundle.getLong(get_key_request_key, &value));
119 EXPECT_GE(value, 0);
120 value = -1;
121 EXPECT_TRUE(bundle.getLong(provide_key_response_key, &value));
122 EXPECT_GE(value, 0);
123 }
124
TEST_F(MediaDrmMetricsTest,AllValuesFull)125 TEST_F(MediaDrmMetricsTest, AllValuesFull) {
126 MediaDrmMetrics metrics;
127
128 metrics.mOpenSessionCounter.Increment(OK);
129 metrics.mOpenSessionCounter.Increment(UNEXPECTED_NULL);
130
131 metrics.mCloseSessionCounter.Increment(OK);
132 metrics.mCloseSessionCounter.Increment(UNEXPECTED_NULL);
133
134 for (status_t s : {OK, UNEXPECTED_NULL}) {
135 {
136 EventTimer<status_t> get_key_request_timer(&metrics.mGetKeyRequestTimeUs);
137 EventTimer<status_t> provide_key_response_timer(
138 &metrics.mProvideKeyResponseTimeUs);
139 get_key_request_timer.SetAttribute(s);
140 provide_key_response_timer.SetAttribute(s);
141 }
142 }
143
144 metrics.mGetProvisionRequestCounter.Increment(OK);
145 metrics.mGetProvisionRequestCounter.Increment(UNEXPECTED_NULL);
146 metrics.mProvideProvisionResponseCounter.Increment(OK);
147 metrics.mProvideProvisionResponseCounter.Increment(UNEXPECTED_NULL);
148 metrics.mGetDeviceUniqueIdCounter.Increment(OK);
149 metrics.mGetDeviceUniqueIdCounter.Increment(UNEXPECTED_NULL);
150
151 metrics.mKeyStatusChangeCounter.Increment(KeyStatusType::USABLE);
152 metrics.mKeyStatusChangeCounter.Increment(KeyStatusType::EXPIRED);
153 metrics.mKeyStatusChangeCounter.Increment(KeyStatusType::OUTPUTNOTALLOWED);
154 metrics.mKeyStatusChangeCounter.Increment(KeyStatusType::STATUSPENDING);
155 metrics.mKeyStatusChangeCounter.Increment(KeyStatusType::INTERNALERROR);
156 metrics.mEventCounter.Increment(EventType::PROVISION_REQUIRED);
157 metrics.mEventCounter.Increment(EventType::KEY_NEEDED);
158 metrics.mEventCounter.Increment(EventType::KEY_EXPIRED);
159 metrics.mEventCounter.Increment(EventType::VENDOR_DEFINED);
160 metrics.mEventCounter.Increment(EventType::SESSION_RECLAIMED);
161
162 android::Vector<uint8_t> sessionId1;
163 sessionId1.push_back(1);
164 sessionId1.push_back(2);
165 android::Vector<uint8_t> sessionId2;
166 sessionId2.push_back(3);
167 sessionId2.push_back(4);
168 String16 hexSessionId1("0102");
169 String16 hexSessionId2("0304");
170
171 metrics.SetSessionStart(sessionId1);
172 metrics.SetSessionStart(sessionId2);
173 metrics.SetSessionEnd(sessionId2);
174 metrics.SetSessionEnd(sessionId1);
175
176 PersistableBundle bundle;
177 metrics.Export(&bundle);
178 EXPECT_EQ(35U, bundle.size());
179
180 // Verify the list of pairs of int64 metrics.
181 std::vector<std::pair<std::string, int64_t>> expected_values = {
182 { "drm.mediadrm.open_session.ok.count", 1 },
183 { "drm.mediadrm.close_session.ok.count", 1 },
184 { "drm.mediadrm.get_key_request.ok.count", 1 },
185 { "drm.mediadrm.provide_key_response.ok.count", 1 },
186 { "drm.mediadrm.get_provision_request.ok.count", 1 },
187 { "drm.mediadrm.provide_provision_response.ok.count", 1 },
188 { "drm.mediadrm.get_device_unique_id.ok.count", 1 },
189 { "drm.mediadrm.open_session.error.count", 1 },
190 { "drm.mediadrm.close_session.error.count", 1 },
191 { "drm.mediadrm.get_key_request.error.count", 1 },
192 { "drm.mediadrm.provide_key_response.error.count", 1 },
193 { "drm.mediadrm.get_provision_request.error.count", 1 },
194 { "drm.mediadrm.provide_provision_response.error.count", 1 },
195 { "drm.mediadrm.get_device_unique_id.error.count", 1 },
196 { "drm.mediadrm.key_status_change.USABLE.count", 1 },
197 { "drm.mediadrm.key_status_change.EXPIRED.count", 1 },
198 { "drm.mediadrm.key_status_change.OUTPUT_NOT_ALLOWED.count", 1 },
199 { "drm.mediadrm.key_status_change.STATUS_PENDING.count", 1 },
200 { "drm.mediadrm.key_status_change.INTERNAL_ERROR.count", 1 },
201 { "drm.mediadrm.event.PROVISION_REQUIRED.count", 1 },
202 { "drm.mediadrm.event.KEY_NEEDED.count", 1 },
203 { "drm.mediadrm.event.KEY_EXPIRED.count", 1 },
204 { "drm.mediadrm.event.VENDOR_DEFINED.count", 1 },
205 { "drm.mediadrm.event.SESSION_RECLAIMED.count", 1 }};
206 for (const auto& expected_pair : expected_values) {
207 String16 key(expected_pair.first.c_str());
208 int64_t value = -1;
209 EXPECT_TRUE(bundle.getLong(key, &value))
210 << "Unexpected error retrieviing key: " << key;
211 EXPECT_EQ(expected_pair.second, value)
212 << "Unexpected value for " << expected_pair.first << ". " << value;
213 }
214
215 // Verify the error lists
216 std::vector<std::pair<std::string, std::vector<int64_t>>> expected_vector_values = {
217 { "drm.mediadrm.close_session.error.list", { UNEXPECTED_NULL } },
218 { "drm.mediadrm.get_device_unique_id.error.list", { UNEXPECTED_NULL } },
219 { "drm.mediadrm.get_key_request.error.list", { UNEXPECTED_NULL } },
220 { "drm.mediadrm.get_provision_request.error.list", { UNEXPECTED_NULL } },
221 { "drm.mediadrm.open_session.error.list", { UNEXPECTED_NULL } },
222 { "drm.mediadrm.provide_key_response.error.list", { UNEXPECTED_NULL } },
223 { "drm.mediadrm.provide_provision_response.error.list", { UNEXPECTED_NULL } }};
224 for (const auto& expected_pair : expected_vector_values) {
225 String16 key(expected_pair.first.c_str());
226 std::vector<int64_t> values;
227 EXPECT_TRUE(bundle.getLongVector(key, &values))
228 << "Unexpected error retrieviing key: " << key;
229 for (auto expected : expected_pair.second) {
230 EXPECT_TRUE(std::find(values.begin(), values.end(), expected) != values.end())
231 << "Could not find " << expected << " for key " << expected_pair.first;
232 }
233 }
234
235 // Verify the lifespans
236 PersistableBundle start_times;
237 PersistableBundle end_times;
238 String16 start_time_key("drm.mediadrm.session_start_times_ms");
239 String16 end_time_key("drm.mediadrm.session_end_times_ms");
240 ASSERT_TRUE(bundle.getPersistableBundle(start_time_key, &start_times));
241 ASSERT_TRUE(bundle.getPersistableBundle(end_time_key, &end_times));
242 EXPECT_EQ(2U, start_times.size());
243 EXPECT_EQ(2U, end_times.size());
244 int64_t start_time, end_time;
245 for (const auto& sid : { hexSessionId1, hexSessionId2 }) {
246 start_time = -1;
247 end_time = -1;
248 EXPECT_TRUE(start_times.getLong(sid, &start_time));
249 EXPECT_TRUE(end_times.getLong(sid, &end_time));
250 EXPECT_GT(start_time, 0);
251 EXPECT_GE(end_time, start_time);
252 }
253
254 // Validate timing values exist.
255 String16 get_key_request_key(
256 "drm.mediadrm.get_key_request.ok.average_time_micros");
257 String16 provide_key_response_key(
258 "drm.mediadrm.provide_key_response.ok.average_time_micros");
259 int64_t value = -1;
260 EXPECT_TRUE(bundle.getLong(get_key_request_key, &value));
261 EXPECT_GE(value, 0);
262 value = -1;
263 EXPECT_TRUE(bundle.getLong(provide_key_response_key, &value));
264 EXPECT_GE(value, 0);
265 }
266
267
TEST_F(MediaDrmMetricsTest,CounterValuesProtoSerialization)268 TEST_F(MediaDrmMetricsTest, CounterValuesProtoSerialization) {
269 MediaDrmMetrics metrics;
270
271 metrics.mOpenSessionCounter.Increment(OK);
272 metrics.mOpenSessionCounter.Increment(UNEXPECTED_NULL);
273 metrics.mCloseSessionCounter.Increment(OK);
274 metrics.mCloseSessionCounter.Increment(UNEXPECTED_NULL);
275
276 metrics.mGetProvisionRequestCounter.Increment(OK);
277 metrics.mGetProvisionRequestCounter.Increment(UNEXPECTED_NULL);
278 metrics.mProvideProvisionResponseCounter.Increment(OK);
279 metrics.mProvideProvisionResponseCounter.Increment(UNEXPECTED_NULL);
280 metrics.mGetDeviceUniqueIdCounter.Increment(OK);
281 metrics.mGetDeviceUniqueIdCounter.Increment(UNEXPECTED_NULL);
282
283 metrics.mKeyStatusChangeCounter.Increment(KeyStatusType::USABLE);
284 metrics.mKeyStatusChangeCounter.Increment(KeyStatusType::EXPIRED);
285 metrics.mKeyStatusChangeCounter.Increment(KeyStatusType::OUTPUTNOTALLOWED);
286 metrics.mKeyStatusChangeCounter.Increment(KeyStatusType::STATUSPENDING);
287 metrics.mKeyStatusChangeCounter.Increment(KeyStatusType::INTERNALERROR);
288 metrics.mEventCounter.Increment(EventType::PROVISION_REQUIRED);
289 metrics.mEventCounter.Increment(EventType::KEY_NEEDED);
290 metrics.mEventCounter.Increment(EventType::KEY_EXPIRED);
291 metrics.mEventCounter.Increment(EventType::VENDOR_DEFINED);
292 metrics.mEventCounter.Increment(EventType::SESSION_RECLAIMED);
293
294 std::string serializedMetrics;
295 ASSERT_EQ(OK, metrics.GetSerializedMetrics(&serializedMetrics));
296
297 DrmFrameworkMetrics metricsProto;
298 ASSERT_TRUE(metricsProto.ParseFromString(serializedMetrics));
299
300 std::string expectedMetrics =
301 "open_session_counter { count: 1 attributes { error_code: -0x7FFFFFF8 } } "
302 "open_session_counter { count: 1 attributes { error_code: 0 } } "
303 "close_session_counter { count: 1 attributes { error_code: -0x7FFFFFF8 } } "
304 "close_session_counter { count: 1 attributes { error_code: 0 } } "
305 "get_provisioning_request_counter { count: 1 attributes { error_code: -0x7FFFFFF8 } } "
306 "get_provisioning_request_counter { count: 1 attributes { error_code: 0 } } "
307 "provide_provisioning_response_counter { count: 1 attributes { error_code: -0x7ffffff8 } } "
308 "provide_provisioning_response_counter { count: 1 attributes { error_code: 0 } } "
309 "get_device_unique_id_counter { count: 1 attributes { error_code: -0x7ffffff8 } } "
310 "get_device_unique_id_counter { count: 1 attributes { error_code: 0 } } "
311 "key_status_change_counter { count: 1 attributes { key_status_type: 0 } } "
312 "key_status_change_counter { count: 1 attributes { key_status_type: 1 } } "
313 "key_status_change_counter { count: 1 attributes { key_status_type: 2 } } "
314 "key_status_change_counter { count: 1 attributes { key_status_type: 3 } } "
315 "key_status_change_counter { count: 1 attributes { key_status_type: 4 } } "
316 "event_callback_counter { count: 1 attributes { event_type: 0 } } "
317 "event_callback_counter { count: 1 attributes { event_type: 1 } } "
318 "event_callback_counter { count: 1 attributes { event_type: 2 } } "
319 "event_callback_counter { count: 1 attributes { event_type: 3 } } "
320 "event_callback_counter { count: 1 attributes { event_type: 4 } } ";
321
322 DrmFrameworkMetrics expectedMetricsProto;
323 ASSERT_TRUE(TextFormat::MergeFromString(expectedMetrics, &expectedMetricsProto));
324
325 std::string diffString;
326 MessageDifferencer differ;
327 differ.ReportDifferencesToString(&diffString);
328 ASSERT_TRUE(differ.Compare(expectedMetricsProto, metricsProto))
329 << diffString;
330 }
331
TEST_F(MediaDrmMetricsTest,TimeMetricsProtoSerialization)332 TEST_F(MediaDrmMetricsTest, TimeMetricsProtoSerialization) {
333 MediaDrmMetrics metrics;
334
335 for (status_t s : {OK, UNEXPECTED_NULL}) {
336 double time = 0;
337 for (int i = 0; i < 5; i++) {
338 time += 1.0;
339 metrics.mGetKeyRequestTimeUs.Record(time, s);
340 metrics.mProvideKeyResponseTimeUs.Record(time, s);
341 }
342 }
343
344 std::string serializedMetrics;
345 ASSERT_EQ(OK, metrics.GetSerializedMetrics(&serializedMetrics));
346
347 DrmFrameworkMetrics metricsProto;
348 ASSERT_TRUE(metricsProto.ParseFromString(serializedMetrics));
349
350 std::string expectedMetrics =
351 "get_key_request_time_us { "
352 " min: 1 max: 5 mean: 3.5 variance: 1 operation_count: 5 "
353 " attributes { error_code: -0x7FFFFFF8 } "
354 "} "
355 "get_key_request_time_us { "
356 " min: 1 max: 5 mean: 3.5 variance: 1 operation_count: 5 "
357 " attributes { error_code: 0 } "
358 "} "
359 "provide_key_response_time_us { "
360 " min: 1 max: 5 mean: 3.5 variance: 1 operation_count: 5 "
361 " attributes { error_code: -0x7FFFFFF8 } "
362 "} "
363 "provide_key_response_time_us { "
364 " min: 1 max: 5 mean: 3.5 variance: 1 operation_count: 5 "
365 " attributes { error_code: 0 } "
366 "} ";
367
368 DrmFrameworkMetrics expectedMetricsProto;
369 ASSERT_TRUE(TextFormat::MergeFromString(expectedMetrics, &expectedMetricsProto));
370
371 std::string diffString;
372 MessageDifferencer differ;
373 differ.ReportDifferencesToString(&diffString);
374 ASSERT_TRUE(differ.Compare(expectedMetricsProto, metricsProto))
375 << diffString;
376 }
377
TEST_F(MediaDrmMetricsTest,SessionLifetimeProtoSerialization)378 TEST_F(MediaDrmMetricsTest, SessionLifetimeProtoSerialization) {
379 // Use the fake so the clock is predictable;
380 FakeMediaDrmMetrics metrics;
381
382 android::Vector<uint8_t> sessionId1;
383 sessionId1.push_back(1);
384 sessionId1.push_back(2);
385 android::Vector<uint8_t> sessionId2;
386 sessionId2.push_back(3);
387 sessionId2.push_back(4);
388
389 metrics.SetSessionStart(sessionId1);
390 metrics.SetSessionStart(sessionId2);
391 metrics.SetSessionEnd(sessionId2);
392 metrics.SetSessionEnd(sessionId1);
393
394 std::string serializedMetrics;
395 ASSERT_EQ(OK, metrics.GetSerializedMetrics(&serializedMetrics));
396
397 DrmFrameworkMetrics metricsProto;
398 ASSERT_TRUE(metricsProto.ParseFromString(serializedMetrics));
399
400 std::string expectedMetrics =
401 "session_lifetimes: { "
402 " key: '0102' "
403 " value { start_time_ms: 0 end_time_ms: 3 } "
404 "} "
405 "session_lifetimes: { "
406 " key: '0304' "
407 " value { start_time_ms: 1 end_time_ms: 2 } "
408 "} ";
409
410 DrmFrameworkMetrics expectedMetricsProto;
411 ASSERT_TRUE(TextFormat::MergeFromString(expectedMetrics, &expectedMetricsProto));
412
413 std::string diffString;
414 MessageDifferencer differ;
415 differ.ReportDifferencesToString(&diffString);
416 ASSERT_TRUE(differ.Compare(expectedMetricsProto, metricsProto))
417 << diffString;
418 }
419
TEST_F(MediaDrmMetricsTest,HidlToBundleMetricsEmpty)420 TEST_F(MediaDrmMetricsTest, HidlToBundleMetricsEmpty) {
421 hidl_vec<DrmMetricGroup> hidlMetricGroups;
422 PersistableBundle bundleMetricGroups;
423
424 ASSERT_EQ(OK, MediaDrmMetrics::HidlMetricsToBundle(hidlMetricGroups, &bundleMetricGroups));
425 ASSERT_EQ(0U, bundleMetricGroups.size());
426 }
427
TEST_F(MediaDrmMetricsTest,HidlToBundleMetricsMultiple)428 TEST_F(MediaDrmMetricsTest, HidlToBundleMetricsMultiple) {
429 DrmMetricGroup hidlMetricGroup =
430 { { {
431 "open_session_ok",
432 { { "status", DrmMetricGroup::ValueType::INT64_TYPE,
433 (int64_t) Status::OK, 0.0, "" } },
434 { { "count", DrmMetricGroup::ValueType::INT64_TYPE, 3, 0.0, "" } }
435 },
436 {
437 "close_session_not_opened",
438 { { "status", DrmMetricGroup::ValueType::INT64_TYPE,
439 (int64_t) Status::ERROR_DRM_SESSION_NOT_OPENED, 0.0, "" } },
440 { { "count", DrmMetricGroup::ValueType::INT64_TYPE, 7, 0.0, "" } }
441 } } };
442
443 PersistableBundle bundleMetricGroups;
444 ASSERT_EQ(OK, MediaDrmMetrics::HidlMetricsToBundle(hidl_vec<DrmMetricGroup>({hidlMetricGroup}),
445 &bundleMetricGroups));
446 ASSERT_EQ(1U, bundleMetricGroups.size());
447 PersistableBundle bundleMetricGroup;
448 ASSERT_TRUE(bundleMetricGroups.getPersistableBundle(String16("[0]"), &bundleMetricGroup));
449 ASSERT_EQ(2U, bundleMetricGroup.size());
450
451 // Verify each metric.
452 PersistableBundle metric;
453 ASSERT_TRUE(bundleMetricGroup.getPersistableBundle(String16("open_session_ok"), &metric));
454 PersistableBundle metricInstance;
455 ASSERT_TRUE(metric.getPersistableBundle(String16("[0]"), &metricInstance));
456 int64_t value = 0;
457 ASSERT_TRUE(metricInstance.getLong(String16("count"), &value));
458 ASSERT_EQ(3, value);
459 PersistableBundle attributeBundle;
460 ASSERT_TRUE(metricInstance.getPersistableBundle(String16("attributes"), &attributeBundle));
461 ASSERT_TRUE(attributeBundle.getLong(String16("status"), &value));
462 ASSERT_EQ((int64_t) Status::OK, value);
463
464 ASSERT_TRUE(bundleMetricGroup.getPersistableBundle(String16("close_session_not_opened"),
465 &metric));
466 ASSERT_TRUE(metric.getPersistableBundle(String16("[0]"), &metricInstance));
467 ASSERT_TRUE(metricInstance.getLong(String16("count"), &value));
468 ASSERT_EQ(7, value);
469 ASSERT_TRUE(metricInstance.getPersistableBundle(String16("attributes"), &attributeBundle));
470 value = 0;
471 ASSERT_TRUE(attributeBundle.getLong(String16("status"), &value));
472 ASSERT_EQ((int64_t) Status::ERROR_DRM_SESSION_NOT_OPENED, value);
473 }
474
475 } // namespace android
476