OLD | NEW |
---|---|
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/cdm/json_web_key.h" | 5 #include "media/cdm/json_web_key.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include "base/base64.h" | 10 #include "base/base64.h" |
11 #include "base/logging.h" | 11 #include "base/logging.h" |
12 #include "base/macros.h" | 12 #include "base/macros.h" |
13 #include "testing/gtest/include/gtest/gtest.h" | 13 #include "testing/gtest/include/gtest/gtest.h" |
14 | 14 |
15 namespace media { | 15 namespace media { |
16 | 16 |
17 class JSONWebKeyTest : public testing::Test { | 17 class JSONWebKeyTest : public testing::Test { |
18 public: | 18 public: |
19 JSONWebKeyTest() {} | 19 JSONWebKeyTest() {} |
20 | 20 |
21 protected: | 21 protected: |
22 void ExtractJWKKeysAndExpect(const std::string& jwk, | 22 void ExtractJWKKeysAndExpect(const std::string& jwk, |
23 bool expected_result, | 23 bool expected_result, |
24 size_t expected_number_of_keys) { | 24 size_t expected_number_of_keys) { |
25 DCHECK(!jwk.empty()); | 25 DCHECK(!jwk.empty()); |
26 KeyIdAndKeyPairs keys; | 26 KeyIdAndKeyPairs keys; |
27 MediaKeys::SessionType session_type; | 27 ContentDecryptionModule::SessionType session_type; |
jrummell
2016/12/12 22:08:40
nit: Should include content_decryption_module.h.
xhwang
2016/12/12 22:32:50
Done.
| |
28 EXPECT_EQ(expected_result, | 28 EXPECT_EQ(expected_result, |
29 ExtractKeysFromJWKSet(jwk, &keys, &session_type)); | 29 ExtractKeysFromJWKSet(jwk, &keys, &session_type)); |
30 EXPECT_EQ(expected_number_of_keys, keys.size()); | 30 EXPECT_EQ(expected_number_of_keys, keys.size()); |
31 } | 31 } |
32 | 32 |
33 void ExtractSessionTypeAndExpect(const std::string& jwk, | 33 void ExtractSessionTypeAndExpect( |
34 bool expected_result, | 34 const std::string& jwk, |
35 MediaKeys::SessionType expected_type) { | 35 bool expected_result, |
36 ContentDecryptionModule::SessionType expected_type) { | |
36 DCHECK(!jwk.empty()); | 37 DCHECK(!jwk.empty()); |
37 KeyIdAndKeyPairs keys; | 38 KeyIdAndKeyPairs keys; |
38 MediaKeys::SessionType session_type; | 39 ContentDecryptionModule::SessionType session_type; |
39 EXPECT_EQ(expected_result, | 40 EXPECT_EQ(expected_result, |
40 ExtractKeysFromJWKSet(jwk, &keys, &session_type)); | 41 ExtractKeysFromJWKSet(jwk, &keys, &session_type)); |
41 if (expected_result) { | 42 if (expected_result) { |
42 // Only check if successful. | 43 // Only check if successful. |
43 EXPECT_EQ(expected_type, session_type); | 44 EXPECT_EQ(expected_type, session_type); |
44 } | 45 } |
45 } | 46 } |
46 | 47 |
47 void CreateLicenseAndExpect(const uint8_t* key_id, | 48 void CreateLicenseAndExpect(const uint8_t* key_id, |
48 int key_id_length, | 49 int key_id_length, |
49 MediaKeys::SessionType session_type, | 50 ContentDecryptionModule::SessionType session_type, |
50 const std::string& expected_result) { | 51 const std::string& expected_result) { |
51 std::vector<uint8_t> result; | 52 std::vector<uint8_t> result; |
52 KeyIdList key_ids; | 53 KeyIdList key_ids; |
53 key_ids.push_back(std::vector<uint8_t>(key_id, key_id + key_id_length)); | 54 key_ids.push_back(std::vector<uint8_t>(key_id, key_id + key_id_length)); |
54 CreateLicenseRequest(key_ids, session_type, &result); | 55 CreateLicenseRequest(key_ids, session_type, &result); |
55 std::string s(result.begin(), result.end()); | 56 std::string s(result.begin(), result.end()); |
56 EXPECT_EQ(expected_result, s); | 57 EXPECT_EQ(expected_result, s); |
57 } | 58 } |
58 | 59 |
59 void ExtractKeyFromLicenseAndExpect(const std::string& license, | 60 void ExtractKeyFromLicenseAndExpect(const std::string& license, |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
104 "{\"keys\":[{\"k\":\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kid\":" | 105 "{\"keys\":[{\"k\":\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kid\":" |
105 "\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kty\":\"oct\"}]}", | 106 "\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kty\":\"oct\"}]}", |
106 GenerateJWKSet(data3, arraysize(data3), data3, arraysize(data3))); | 107 GenerateJWKSet(data3, arraysize(data3), data3, arraysize(data3))); |
107 | 108 |
108 KeyIdAndKeyPairs keys; | 109 KeyIdAndKeyPairs keys; |
109 keys.push_back( | 110 keys.push_back( |
110 MakeKeyIdAndKeyPair(data1, arraysize(data1), data1, arraysize(data1))); | 111 MakeKeyIdAndKeyPair(data1, arraysize(data1), data1, arraysize(data1))); |
111 EXPECT_EQ( | 112 EXPECT_EQ( |
112 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":" | 113 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":" |
113 "\"temporary\"}", | 114 "\"temporary\"}", |
114 GenerateJWKSet(keys, MediaKeys::TEMPORARY_SESSION)); | 115 GenerateJWKSet(keys, ContentDecryptionModule::TEMPORARY_SESSION)); |
115 keys.push_back( | 116 keys.push_back( |
116 MakeKeyIdAndKeyPair(data2, arraysize(data2), data2, arraysize(data2))); | 117 MakeKeyIdAndKeyPair(data2, arraysize(data2), data2, arraysize(data2))); |
117 EXPECT_EQ( | 118 EXPECT_EQ( |
118 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"},{\"k\":" | 119 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"},{\"k\":" |
119 "\"AQIDBA\",\"kid\":\"AQIDBA\",\"kty\":\"oct\"}],\"type\":\"persistent-" | 120 "\"AQIDBA\",\"kid\":\"AQIDBA\",\"kty\":\"oct\"}],\"type\":\"persistent-" |
120 "license\"}", | 121 "license\"}", |
121 GenerateJWKSet(keys, MediaKeys::PERSISTENT_LICENSE_SESSION)); | 122 GenerateJWKSet(keys, |
123 ContentDecryptionModule::PERSISTENT_LICENSE_SESSION)); | |
122 keys.push_back( | 124 keys.push_back( |
123 MakeKeyIdAndKeyPair(data3, arraysize(data3), data3, arraysize(data3))); | 125 MakeKeyIdAndKeyPair(data3, arraysize(data3), data3, arraysize(data3))); |
124 EXPECT_EQ( | 126 EXPECT_EQ( |
125 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"},{\"k\":" | 127 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"},{\"k\":" |
126 "\"AQIDBA\",\"kid\":\"AQIDBA\",\"kty\":\"oct\"},{\"k\":" | 128 "\"AQIDBA\",\"kid\":\"AQIDBA\",\"kty\":\"oct\"},{\"k\":" |
127 "\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kid\":\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kty\":" | 129 "\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kid\":\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kty\":" |
128 "\"oct\"}],\"type\":\"persistent-release-message\"}", | 130 "\"oct\"}],\"type\":\"persistent-release-message\"}", |
129 GenerateJWKSet(keys, MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION)); | 131 GenerateJWKSet( |
132 keys, ContentDecryptionModule::PERSISTENT_RELEASE_MESSAGE_SESSION)); | |
130 } | 133 } |
131 | 134 |
132 TEST_F(JSONWebKeyTest, ExtractValidJWKKeys) { | 135 TEST_F(JSONWebKeyTest, ExtractValidJWKKeys) { |
133 // Try an empty 'keys' dictionary. | 136 // Try an empty 'keys' dictionary. |
134 ExtractJWKKeysAndExpect("{ \"keys\": [] }", true, 0); | 137 ExtractJWKKeysAndExpect("{ \"keys\": [] }", true, 0); |
135 | 138 |
136 // Try a key list with one entry. | 139 // Try a key list with one entry. |
137 const std::string kJwksOneEntry = | 140 const std::string kJwksOneEntry = |
138 "{" | 141 "{" |
139 " \"keys\": [" | 142 " \"keys\": [" |
(...skipping 250 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
390 " \"k\": \"BAUGBwgJCgsMDQ4PEBESEw\"" | 393 " \"k\": \"BAUGBwgJCgsMDQ4PEBESEw\"" |
391 " }" | 394 " }" |
392 " ]" | 395 " ]" |
393 "}"; | 396 "}"; |
394 ExtractJWKKeysAndExpect(kJwksWithWrongAlg, true, 1); | 397 ExtractJWKKeysAndExpect(kJwksWithWrongAlg, true, 1); |
395 } | 398 } |
396 | 399 |
397 TEST_F(JSONWebKeyTest, SessionType) { | 400 TEST_F(JSONWebKeyTest, SessionType) { |
398 ExtractSessionTypeAndExpect( | 401 ExtractSessionTypeAndExpect( |
399 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}]}", true, | 402 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}]}", true, |
400 MediaKeys::TEMPORARY_SESSION); | 403 ContentDecryptionModule::TEMPORARY_SESSION); |
401 ExtractSessionTypeAndExpect( | 404 ExtractSessionTypeAndExpect( |
402 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":" | 405 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":" |
403 "\"temporary\"}", | 406 "\"temporary\"}", |
404 true, MediaKeys::TEMPORARY_SESSION); | 407 true, ContentDecryptionModule::TEMPORARY_SESSION); |
405 ExtractSessionTypeAndExpect( | 408 ExtractSessionTypeAndExpect( |
406 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":" | 409 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":" |
407 "\"persistent-license\"}", | 410 "\"persistent-license\"}", |
408 true, MediaKeys::PERSISTENT_LICENSE_SESSION); | 411 true, ContentDecryptionModule::PERSISTENT_LICENSE_SESSION); |
409 ExtractSessionTypeAndExpect( | 412 ExtractSessionTypeAndExpect( |
410 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":" | 413 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":" |
411 "\"persistent-release-message\"}", | 414 "\"persistent-release-message\"}", |
412 true, MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION); | 415 true, ContentDecryptionModule::PERSISTENT_RELEASE_MESSAGE_SESSION); |
413 ExtractSessionTypeAndExpect( | 416 ExtractSessionTypeAndExpect( |
414 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":" | 417 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":" |
415 "\"unknown\"}", | 418 "\"unknown\"}", |
416 false, MediaKeys::TEMPORARY_SESSION); | 419 false, ContentDecryptionModule::TEMPORARY_SESSION); |
417 ExtractSessionTypeAndExpect( | 420 ExtractSessionTypeAndExpect( |
418 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":3}", | 421 "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":3}", |
419 false, MediaKeys::TEMPORARY_SESSION); | 422 false, ContentDecryptionModule::TEMPORARY_SESSION); |
420 } | 423 } |
421 | 424 |
422 TEST_F(JSONWebKeyTest, CreateLicense) { | 425 TEST_F(JSONWebKeyTest, CreateLicense) { |
423 const uint8_t data1[] = {0x01, 0x02}; | 426 const uint8_t data1[] = {0x01, 0x02}; |
424 const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04}; | 427 const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04}; |
425 const uint8_t data3[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, | 428 const uint8_t data3[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
426 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10}; | 429 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10}; |
427 | 430 |
428 CreateLicenseAndExpect(data1, | 431 CreateLicenseAndExpect(data1, arraysize(data1), |
429 arraysize(data1), | 432 ContentDecryptionModule::TEMPORARY_SESSION, |
430 MediaKeys::TEMPORARY_SESSION, | |
431 "{\"kids\":[\"AQI\"],\"type\":\"temporary\"}"); | 433 "{\"kids\":[\"AQI\"],\"type\":\"temporary\"}"); |
432 CreateLicenseAndExpect( | 434 CreateLicenseAndExpect( |
433 data1, arraysize(data1), MediaKeys::PERSISTENT_LICENSE_SESSION, | 435 data1, arraysize(data1), |
436 ContentDecryptionModule::PERSISTENT_LICENSE_SESSION, | |
434 "{\"kids\":[\"AQI\"],\"type\":\"persistent-license\"}"); | 437 "{\"kids\":[\"AQI\"],\"type\":\"persistent-license\"}"); |
435 CreateLicenseAndExpect( | 438 CreateLicenseAndExpect( |
436 data1, arraysize(data1), MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION, | 439 data1, arraysize(data1), |
440 ContentDecryptionModule::PERSISTENT_RELEASE_MESSAGE_SESSION, | |
437 "{\"kids\":[\"AQI\"],\"type\":\"persistent-release-message\"}"); | 441 "{\"kids\":[\"AQI\"],\"type\":\"persistent-release-message\"}"); |
438 CreateLicenseAndExpect(data2, | 442 CreateLicenseAndExpect(data2, arraysize(data2), |
439 arraysize(data2), | 443 ContentDecryptionModule::TEMPORARY_SESSION, |
440 MediaKeys::TEMPORARY_SESSION, | |
441 "{\"kids\":[\"AQIDBA\"],\"type\":\"temporary\"}"); | 444 "{\"kids\":[\"AQIDBA\"],\"type\":\"temporary\"}"); |
442 CreateLicenseAndExpect(data3, arraysize(data3), | 445 CreateLicenseAndExpect(data3, arraysize(data3), |
443 MediaKeys::PERSISTENT_LICENSE_SESSION, | 446 ContentDecryptionModule::PERSISTENT_LICENSE_SESSION, |
444 "{\"kids\":[\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":" | 447 "{\"kids\":[\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":" |
445 "\"persistent-license\"}"); | 448 "\"persistent-license\"}"); |
446 } | 449 } |
447 | 450 |
448 TEST_F(JSONWebKeyTest, ExtractLicense) { | 451 TEST_F(JSONWebKeyTest, ExtractLicense) { |
449 const uint8_t data1[] = {0x01, 0x02}; | 452 const uint8_t data1[] = {0x01, 0x02}; |
450 const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04}; | 453 const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04}; |
451 const uint8_t data3[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, | 454 const uint8_t data3[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
452 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10}; | 455 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10}; |
453 | 456 |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
499 &encoded_text); | 502 &encoded_text); |
500 EXPECT_EQ(encoded_text, "+/37/fv9+w=="); | 503 EXPECT_EQ(encoded_text, "+/37/fv9+w=="); |
501 EXPECT_NE(encoded_text.find('+'), std::string::npos); | 504 EXPECT_NE(encoded_text.find('+'), std::string::npos); |
502 EXPECT_NE(encoded_text.find('/'), std::string::npos); | 505 EXPECT_NE(encoded_text.find('/'), std::string::npos); |
503 EXPECT_NE(encoded_text.find('='), std::string::npos); | 506 EXPECT_NE(encoded_text.find('='), std::string::npos); |
504 | 507 |
505 // base64url characters '-' and '_' not in base64 encoding. | 508 // base64url characters '-' and '_' not in base64 encoding. |
506 EXPECT_EQ(encoded_text.find('-'), std::string::npos); | 509 EXPECT_EQ(encoded_text.find('-'), std::string::npos); |
507 EXPECT_EQ(encoded_text.find('_'), std::string::npos); | 510 EXPECT_EQ(encoded_text.find('_'), std::string::npos); |
508 | 511 |
509 CreateLicenseAndExpect(data1, arraysize(data1), MediaKeys::TEMPORARY_SESSION, | 512 CreateLicenseAndExpect(data1, arraysize(data1), |
513 ContentDecryptionModule::TEMPORARY_SESSION, | |
510 "{\"kids\":[\"-_37_fv9-w\"],\"type\":\"temporary\"}"); | 514 "{\"kids\":[\"-_37_fv9-w\"],\"type\":\"temporary\"}"); |
511 | 515 |
512 ExtractKeyFromLicenseAndExpect( | 516 ExtractKeyFromLicenseAndExpect( |
513 "{\"kids\":[\"-_37_fv9-w\"],\"type\":\"temporary\"}", true, data1, | 517 "{\"kids\":[\"-_37_fv9-w\"],\"type\":\"temporary\"}", true, data1, |
514 arraysize(data1)); | 518 arraysize(data1)); |
515 } | 519 } |
516 | 520 |
517 TEST_F(JSONWebKeyTest, MultipleKeys) { | 521 TEST_F(JSONWebKeyTest, MultipleKeys) { |
518 const uint8_t data1[] = {0x01, 0x02}; | 522 const uint8_t data1[] = {0x01, 0x02}; |
519 const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04}; | 523 const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04}; |
520 const uint8_t data3[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, | 524 const uint8_t data3[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
521 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10}; | 525 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10}; |
522 | 526 |
523 std::vector<uint8_t> result; | 527 std::vector<uint8_t> result; |
524 KeyIdList key_ids; | 528 KeyIdList key_ids; |
525 key_ids.push_back(std::vector<uint8_t>(data1, data1 + arraysize(data1))); | 529 key_ids.push_back(std::vector<uint8_t>(data1, data1 + arraysize(data1))); |
526 key_ids.push_back(std::vector<uint8_t>(data2, data2 + arraysize(data2))); | 530 key_ids.push_back(std::vector<uint8_t>(data2, data2 + arraysize(data2))); |
527 key_ids.push_back(std::vector<uint8_t>(data3, data3 + arraysize(data3))); | 531 key_ids.push_back(std::vector<uint8_t>(data3, data3 + arraysize(data3))); |
528 CreateLicenseRequest(key_ids, MediaKeys::TEMPORARY_SESSION, &result); | 532 CreateLicenseRequest(key_ids, ContentDecryptionModule::TEMPORARY_SESSION, |
533 &result); | |
529 std::string s(result.begin(), result.end()); | 534 std::string s(result.begin(), result.end()); |
530 EXPECT_EQ( | 535 EXPECT_EQ( |
531 "{\"kids\":[\"AQI\",\"AQIDBA\",\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":" | 536 "{\"kids\":[\"AQI\",\"AQIDBA\",\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":" |
532 "\"temporary\"}", | 537 "\"temporary\"}", |
533 s); | 538 s); |
534 } | 539 } |
535 | 540 |
536 TEST_F(JSONWebKeyTest, ExtractKeyIds) { | 541 TEST_F(JSONWebKeyTest, ExtractKeyIds) { |
537 const uint8_t data1[] = {0x01, 0x02}; | 542 const uint8_t data1[] = {0x01, 0x02}; |
538 const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04}; | 543 const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04}; |
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
635 key_ids.push_back(std::vector<uint8_t>(data3, data3 + arraysize(data3))); | 640 key_ids.push_back(std::vector<uint8_t>(data3, data3 + arraysize(data3))); |
636 std::vector<uint8_t> init_data3; | 641 std::vector<uint8_t> init_data3; |
637 CreateKeyIdsInitData(key_ids, &init_data3); | 642 CreateKeyIdsInitData(key_ids, &init_data3); |
638 std::string result3(init_data3.begin(), init_data3.end()); | 643 std::string result3(init_data3.begin(), init_data3.end()); |
639 EXPECT_EQ(result3, | 644 EXPECT_EQ(result3, |
640 "{\"kids\":[\"AQI\",\"AQIDBA\",\"AQIDBAUGBwgJCgsMDQ4PEA\"]}"); | 645 "{\"kids\":[\"AQI\",\"AQIDBA\",\"AQIDBAUGBwgJCgsMDQ4PEA\"]}"); |
641 } | 646 } |
642 | 647 |
643 } // namespace media | 648 } // namespace media |
644 | 649 |
OLD | NEW |