1 // 2 // Copyright (C) 2015 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 #include <base/at_exit.h> 18 #include <base/run_loop.h> 19 #include <gmock/gmock.h> 20 #include <gtest/gtest.h> 21 22 #include "tpm_manager/server/mock_local_data_store.h" 23 #include "tpm_manager/server/mock_tpm_initializer.h" 24 #include "tpm_manager/server/mock_tpm_nvram.h" 25 #include "tpm_manager/server/mock_tpm_status.h" 26 #include "tpm_manager/server/tpm_manager_service.h" 27 28 using testing::_; 29 using testing::AtLeast; 30 using testing::Invoke; 31 using testing::NiceMock; 32 using testing::Return; 33 using testing::SaveArg; 34 using testing::SetArgPointee; 35 36 namespace { 37 38 const char kOwnerPassword[] = "owner"; 39 const char kOwnerDependency[] = "owner_dependency"; 40 const char kOtherDependency[] = "other_dependency"; 41 42 base::AtExitManager dummy; 43 44 } // namespace 45 46 namespace tpm_manager { 47 48 // A test fixture that takes care of message loop management and configuring a 49 // TpmManagerService instance with mock dependencies. 50 class TpmManagerServiceTest : public testing::Test { 51 public: 52 ~TpmManagerServiceTest() override = default; 53 void SetUp() override { 54 service_.reset(new TpmManagerService( 55 true /*wait_for_ownership*/, &mock_local_data_store_, &mock_tpm_status_, 56 &mock_tpm_initializer_, &mock_tpm_nvram_)); 57 SetupService(); 58 } 59 60 protected: 61 void Run() { run_loop_.Run(); } 62 63 void RunServiceWorkerAndQuit() { 64 // Run out the service worker loop by posting a new command and waiting for 65 // the response. 66 auto callback = [](decltype(this) test, const GetTpmStatusReply& reply) { 67 test->Quit(); 68 }; 69 GetTpmStatusRequest request; 70 service_->GetTpmStatus(request, 71 base::Bind(callback, base::Unretained(this))); 72 Run(); 73 } 74 75 void Quit() { run_loop_.Quit(); } 76 77 void SetupService() { CHECK(service_->Initialize()); } 78 79 NiceMock<MockLocalDataStore> mock_local_data_store_; 80 NiceMock<MockTpmInitializer> mock_tpm_initializer_; 81 NiceMock<MockTpmNvram> mock_tpm_nvram_; 82 NiceMock<MockTpmStatus> mock_tpm_status_; 83 std::unique_ptr<TpmManagerService> service_; 84 85 private: 86 base::MessageLoop message_loop_; 87 base::RunLoop run_loop_; 88 }; 89 90 // Tests must call SetupService(). 91 class TpmManagerServiceTest_NoWaitForOwnership : public TpmManagerServiceTest { 92 public: 93 ~TpmManagerServiceTest_NoWaitForOwnership() override = default; 94 void SetUp() override { 95 service_.reset(new TpmManagerService( 96 false /*wait_for_ownership*/, &mock_local_data_store_, 97 &mock_tpm_status_, &mock_tpm_initializer_, &mock_tpm_nvram_)); 98 } 99 }; 100 101 TEST_F(TpmManagerServiceTest_NoWaitForOwnership, AutoInitialize) { 102 // Make sure InitializeTpm doesn't get multiple calls. 103 EXPECT_CALL(mock_tpm_initializer_, InitializeTpm()).Times(1); 104 SetupService(); 105 RunServiceWorkerAndQuit(); 106 } 107 108 TEST_F(TpmManagerServiceTest_NoWaitForOwnership, AutoInitializeNoTpm) { 109 EXPECT_CALL(mock_tpm_status_, IsTpmEnabled()).WillRepeatedly(Return(false)); 110 EXPECT_CALL(mock_tpm_initializer_, InitializeTpm()).Times(0); 111 SetupService(); 112 RunServiceWorkerAndQuit(); 113 } 114 115 TEST_F(TpmManagerServiceTest_NoWaitForOwnership, AutoInitializeFailure) { 116 EXPECT_CALL(mock_tpm_initializer_, InitializeTpm()) 117 .WillRepeatedly(Return(false)); 118 SetupService(); 119 RunServiceWorkerAndQuit(); 120 } 121 122 TEST_F(TpmManagerServiceTest_NoWaitForOwnership, 123 TakeOwnershipAfterAutoInitialize) { 124 EXPECT_CALL(mock_tpm_initializer_, InitializeTpm()).Times(AtLeast(2)); 125 SetupService(); 126 auto callback = [](decltype(this) test, const TakeOwnershipReply& reply) { 127 EXPECT_EQ(STATUS_SUCCESS, reply.status()); 128 test->Quit(); 129 }; 130 TakeOwnershipRequest request; 131 service_->TakeOwnership(request, base::Bind(callback, base::Unretained(this))); 132 Run(); 133 } 134 135 TEST_F(TpmManagerServiceTest, NoAutoInitialize) { 136 EXPECT_CALL(mock_tpm_initializer_, InitializeTpm()).Times(0); 137 RunServiceWorkerAndQuit(); 138 } 139 140 TEST_F(TpmManagerServiceTest, GetTpmStatusSuccess) { 141 EXPECT_CALL(mock_tpm_status_, GetDictionaryAttackInfo(_, _, _, _)) 142 .WillRepeatedly(Invoke([](int* counter, int* threshold, bool* lockout, 143 int* seconds_remaining) { 144 *counter = 5; 145 *threshold = 6; 146 *lockout = true; 147 *seconds_remaining = 7; 148 return true; 149 })); 150 LocalData local_data; 151 local_data.set_owner_password(kOwnerPassword); 152 EXPECT_CALL(mock_local_data_store_, Read(_)) 153 .WillRepeatedly(DoAll(SetArgPointee<0>(local_data), Return(true))); 154 155 auto callback = [](decltype(this) test, const GetTpmStatusReply& reply) { 156 EXPECT_EQ(STATUS_SUCCESS, reply.status()); 157 EXPECT_TRUE(reply.enabled()); 158 EXPECT_TRUE(reply.owned()); 159 EXPECT_EQ(kOwnerPassword, reply.local_data().owner_password()); 160 EXPECT_EQ(5, reply.dictionary_attack_counter()); 161 EXPECT_EQ(6, reply.dictionary_attack_threshold()); 162 EXPECT_TRUE(reply.dictionary_attack_lockout_in_effect()); 163 EXPECT_EQ(7, reply.dictionary_attack_lockout_seconds_remaining()); 164 test->Quit(); 165 }; 166 GetTpmStatusRequest request; 167 service_->GetTpmStatus(request, base::Bind(callback, base::Unretained(this))); 168 Run(); 169 } 170 171 TEST_F(TpmManagerServiceTest, GetTpmStatusLocalDataFailure) { 172 EXPECT_CALL(mock_local_data_store_, Read(_)).WillRepeatedly(Return(false)); 173 auto callback = [](decltype(this) test, const GetTpmStatusReply& reply) { 174 EXPECT_EQ(STATUS_SUCCESS, reply.status()); 175 EXPECT_TRUE(reply.enabled()); 176 EXPECT_TRUE(reply.owned()); 177 EXPECT_FALSE(reply.has_local_data()); 178 EXPECT_TRUE(reply.has_dictionary_attack_counter()); 179 EXPECT_TRUE(reply.has_dictionary_attack_threshold()); 180 EXPECT_TRUE(reply.has_dictionary_attack_lockout_in_effect()); 181 EXPECT_TRUE(reply.has_dictionary_attack_lockout_seconds_remaining()); 182 test->Quit(); 183 }; 184 GetTpmStatusRequest request; 185 service_->GetTpmStatus(request, base::Bind(callback, base::Unretained(this))); 186 Run(); 187 } 188 189 TEST_F(TpmManagerServiceTest, GetTpmStatusNoTpm) { 190 EXPECT_CALL(mock_tpm_status_, IsTpmEnabled()).WillRepeatedly(Return(false)); 191 EXPECT_CALL(mock_tpm_status_, GetDictionaryAttackInfo(_, _, _, _)) 192 .WillRepeatedly(Return(false)); 193 auto callback = [](decltype(this) test, const GetTpmStatusReply& reply) { 194 EXPECT_EQ(STATUS_SUCCESS, reply.status()); 195 EXPECT_FALSE(reply.enabled()); 196 EXPECT_TRUE(reply.owned()); 197 EXPECT_TRUE(reply.has_local_data()); 198 EXPECT_FALSE(reply.has_dictionary_attack_counter()); 199 EXPECT_FALSE(reply.has_dictionary_attack_threshold()); 200 EXPECT_FALSE(reply.has_dictionary_attack_lockout_in_effect()); 201 EXPECT_FALSE(reply.has_dictionary_attack_lockout_seconds_remaining()); 202 test->Quit(); 203 }; 204 GetTpmStatusRequest request; 205 service_->GetTpmStatus(request, base::Bind(callback, base::Unretained(this))); 206 Run(); 207 } 208 209 TEST_F(TpmManagerServiceTest, TakeOwnershipSuccess) { 210 // Make sure InitializeTpm doesn't get multiple calls. 211 EXPECT_CALL(mock_tpm_initializer_, InitializeTpm()).Times(1); 212 auto callback = [](decltype(this) test, const TakeOwnershipReply& reply) { 213 EXPECT_EQ(STATUS_SUCCESS, reply.status()); 214 test->Quit(); 215 }; 216 TakeOwnershipRequest request; 217 service_->TakeOwnership(request, base::Bind(callback, base::Unretained(this))); 218 Run(); 219 } 220 221 TEST_F(TpmManagerServiceTest, TakeOwnershipFailure) { 222 EXPECT_CALL(mock_tpm_initializer_, InitializeTpm()) 223 .WillRepeatedly(Return(false)); 224 auto callback = [](decltype(this) test, const TakeOwnershipReply& reply) { 225 EXPECT_EQ(STATUS_DEVICE_ERROR, reply.status()); 226 test->Quit(); 227 }; 228 TakeOwnershipRequest request; 229 service_->TakeOwnership(request, base::Bind(callback, base::Unretained(this))); 230 Run(); 231 } 232 233 TEST_F(TpmManagerServiceTest, TakeOwnershipNoTpm) { 234 EXPECT_CALL(mock_tpm_status_, IsTpmEnabled()).WillRepeatedly(Return(false)); 235 auto callback = [](decltype(this) test, const TakeOwnershipReply& reply) { 236 EXPECT_EQ(STATUS_NOT_AVAILABLE, reply.status()); 237 test->Quit(); 238 }; 239 TakeOwnershipRequest request; 240 service_->TakeOwnership(request, base::Bind(callback, base::Unretained(this))); 241 Run(); 242 } 243 244 TEST_F(TpmManagerServiceTest, RemoveOwnerDependencyReadFailure) { 245 EXPECT_CALL(mock_local_data_store_, Read(_)).WillRepeatedly(Return(false)); 246 auto callback = [](decltype(this) test, const RemoveOwnerDependencyReply& reply) { 247 EXPECT_EQ(STATUS_DEVICE_ERROR, reply.status()); 248 test->Quit(); 249 }; 250 RemoveOwnerDependencyRequest request; 251 request.set_owner_dependency(kOwnerDependency); 252 service_->RemoveOwnerDependency(request, base::Bind(callback, base::Unretained(this))); 253 Run(); 254 } 255 256 TEST_F(TpmManagerServiceTest, RemoveOwnerDependencyWriteFailure) { 257 EXPECT_CALL(mock_local_data_store_, Write(_)).WillRepeatedly(Return(false)); 258 auto callback = [](decltype(this) test, const RemoveOwnerDependencyReply& reply) { 259 EXPECT_EQ(STATUS_DEVICE_ERROR, reply.status()); 260 test->Quit(); 261 }; 262 RemoveOwnerDependencyRequest request; 263 request.set_owner_dependency(kOwnerDependency); 264 service_->RemoveOwnerDependency(request, base::Bind(callback, base::Unretained(this))); 265 Run(); 266 } 267 268 TEST_F(TpmManagerServiceTest, RemoveOwnerDependencyNotCleared) { 269 LocalData local_data; 270 local_data.set_owner_password(kOwnerPassword); 271 local_data.add_owner_dependency(kOwnerDependency); 272 local_data.add_owner_dependency(kOtherDependency); 273 EXPECT_CALL(mock_local_data_store_, Read(_)) 274 .WillOnce(DoAll(SetArgPointee<0>(local_data), Return(true))); 275 EXPECT_CALL(mock_local_data_store_, Write(_)) 276 .WillOnce(DoAll(SaveArg<0>(&local_data), Return(true))); 277 auto callback = [](decltype(this) test, LocalData* local_data, 278 const RemoveOwnerDependencyReply& reply) { 279 EXPECT_EQ(STATUS_SUCCESS, reply.status()); 280 EXPECT_EQ(1, local_data->owner_dependency_size()); 281 EXPECT_EQ(kOtherDependency, local_data->owner_dependency(0)); 282 EXPECT_TRUE(local_data->has_owner_password()); 283 EXPECT_EQ(kOwnerPassword, local_data->owner_password()); 284 test->Quit(); 285 }; 286 RemoveOwnerDependencyRequest request; 287 request.set_owner_dependency(kOwnerDependency); 288 service_->RemoveOwnerDependency(request, 289 base::Bind(callback, base::Unretained(this), 290 base::Unretained(&local_data))); 291 Run(); 292 } 293 294 TEST_F(TpmManagerServiceTest, RemoveOwnerDependencyCleared) { 295 LocalData local_data; 296 local_data.set_owner_password(kOwnerPassword); 297 local_data.add_owner_dependency(kOwnerDependency); 298 EXPECT_CALL(mock_local_data_store_, Read(_)) 299 .WillOnce(DoAll(SetArgPointee<0>(local_data), Return(true))); 300 EXPECT_CALL(mock_local_data_store_, Write(_)) 301 .WillOnce(DoAll(SaveArg<0>(&local_data), Return(true))); 302 auto callback = [](decltype(this) test, LocalData* local_data, 303 const RemoveOwnerDependencyReply& reply) { 304 EXPECT_EQ(STATUS_SUCCESS, reply.status()); 305 EXPECT_EQ(0, local_data->owner_dependency_size()); 306 EXPECT_FALSE(local_data->has_owner_password()); 307 test->Quit(); 308 }; 309 RemoveOwnerDependencyRequest request; 310 request.set_owner_dependency(kOwnerDependency); 311 service_->RemoveOwnerDependency(request, 312 base::Bind(callback, base::Unretained(this), 313 base::Unretained(&local_data))); 314 Run(); 315 } 316 317 TEST_F(TpmManagerServiceTest, RemoveOwnerDependencyNotPresent) { 318 LocalData local_data; 319 local_data.set_owner_password(kOwnerPassword); 320 local_data.add_owner_dependency(kOwnerDependency); 321 EXPECT_CALL(mock_local_data_store_, Read(_)) 322 .WillOnce(DoAll(SetArgPointee<0>(local_data), Return(true))); 323 EXPECT_CALL(mock_local_data_store_, Write(_)) 324 .WillOnce(DoAll(SaveArg<0>(&local_data), Return(true))); 325 auto callback = [](decltype(this) test, const LocalData& local_data, 326 const RemoveOwnerDependencyReply& reply) { 327 EXPECT_EQ(STATUS_SUCCESS, reply.status()); 328 EXPECT_EQ(1, local_data.owner_dependency_size()); 329 EXPECT_EQ(kOwnerDependency, local_data.owner_dependency(0)); 330 EXPECT_TRUE(local_data.has_owner_password()); 331 EXPECT_EQ(kOwnerPassword, local_data.owner_password()); 332 test->Quit(); 333 }; 334 RemoveOwnerDependencyRequest request; 335 request.set_owner_dependency(kOtherDependency); 336 service_->RemoveOwnerDependency( 337 request, base::Bind(callback, base::Unretained(this), local_data)); 338 Run(); 339 } 340 341 TEST_F(TpmManagerServiceTest, DefineSpaceFailure) { 342 uint32_t nvram_index = 5; 343 size_t nvram_size = 32; 344 std::vector<NvramSpaceAttribute> attributes{NVRAM_BOOT_WRITE_LOCK}; 345 NvramSpacePolicy policy = NVRAM_POLICY_PCR0; 346 std::string auth_value = "1234"; 347 EXPECT_CALL(mock_tpm_nvram_, DefineSpace(nvram_index, nvram_size, attributes, 348 auth_value, policy)) 349 .WillRepeatedly(Return(NVRAM_RESULT_INVALID_PARAMETER)); 350 auto callback = [](decltype(this) test, const DefineSpaceReply& reply) { 351 EXPECT_EQ(NVRAM_RESULT_INVALID_PARAMETER, reply.result()); 352 test->Quit(); 353 }; 354 DefineSpaceRequest request; 355 request.set_index(nvram_index); 356 request.set_size(nvram_size); 357 request.add_attributes(NVRAM_BOOT_WRITE_LOCK); 358 request.set_policy(policy); 359 request.set_authorization_value(auth_value); 360 service_->DefineSpace(request, base::Bind(callback, base::Unretained(this))); 361 Run(); 362 } 363 364 TEST_F(TpmManagerServiceTest, DefineSpaceSuccess) { 365 uint32_t nvram_index = 5; 366 uint32_t nvram_size = 32; 367 auto define_callback = [](const DefineSpaceReply& reply) { 368 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 369 }; 370 auto list_callback = [](uint32_t nvram_index, const ListSpacesReply& reply) { 371 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 372 EXPECT_EQ(1, reply.index_list_size()); 373 EXPECT_EQ(nvram_index, reply.index_list(0)); 374 }; 375 auto info_callback = [](uint32_t nvram_size, const GetSpaceInfoReply& reply) { 376 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 377 EXPECT_EQ(nvram_size, reply.size()); 378 }; 379 DefineSpaceRequest define_request; 380 define_request.set_index(nvram_index); 381 define_request.set_size(nvram_size); 382 service_->DefineSpace(define_request, base::Bind(define_callback)); 383 ListSpacesRequest list_request; 384 service_->ListSpaces(list_request, base::Bind(list_callback, nvram_index)); 385 GetSpaceInfoRequest info_request; 386 info_request.set_index(nvram_index); 387 service_->GetSpaceInfo(info_request, base::Bind(info_callback, nvram_size)); 388 RunServiceWorkerAndQuit(); 389 } 390 391 TEST_F(TpmManagerServiceTest, DestroyUnitializedNvram) { 392 auto callback = [](decltype(this) test, const DestroySpaceReply& reply) { 393 EXPECT_EQ(NVRAM_RESULT_SPACE_DOES_NOT_EXIST, reply.result()); 394 test->Quit(); 395 }; 396 DestroySpaceRequest request; 397 service_->DestroySpace(request, base::Bind(callback, base::Unretained(this))); 398 Run(); 399 } 400 401 TEST_F(TpmManagerServiceTest, DestroySpaceSuccess) { 402 uint32_t nvram_index = 5; 403 uint32_t nvram_size = 32; 404 auto define_callback = [](const DefineSpaceReply& reply) { 405 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 406 }; 407 auto destroy_callback = [](const DestroySpaceReply& reply) { 408 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 409 }; 410 DefineSpaceRequest define_request; 411 define_request.set_index(nvram_index); 412 define_request.set_size(nvram_size); 413 service_->DefineSpace(define_request, base::Bind(define_callback)); 414 DestroySpaceRequest destroy_request; 415 destroy_request.set_index(nvram_index); 416 service_->DestroySpace(destroy_request, base::Bind(destroy_callback)); 417 RunServiceWorkerAndQuit(); 418 } 419 420 TEST_F(TpmManagerServiceTest, DoubleDestroySpace) { 421 uint32_t nvram_index = 5; 422 uint32_t nvram_size = 32; 423 auto define_callback = [](const DefineSpaceReply& reply) { 424 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 425 }; 426 auto destroy_callback_success = [](const DestroySpaceReply& reply) { 427 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 428 }; 429 auto destroy_callback_failure = [](const DestroySpaceReply& reply) { 430 EXPECT_EQ(NVRAM_RESULT_SPACE_DOES_NOT_EXIST, reply.result()); 431 }; 432 DefineSpaceRequest define_request; 433 define_request.set_index(nvram_index); 434 define_request.set_size(nvram_size); 435 service_->DefineSpace(define_request, base::Bind(define_callback)); 436 DestroySpaceRequest destroy_request; 437 destroy_request.set_index(nvram_index); 438 service_->DestroySpace(destroy_request, base::Bind(destroy_callback_success)); 439 service_->DestroySpace(destroy_request, base::Bind(destroy_callback_failure)); 440 RunServiceWorkerAndQuit(); 441 } 442 443 TEST_F(TpmManagerServiceTest, WriteSpaceIncorrectSize) { 444 uint32_t nvram_index = 5; 445 std::string nvram_data("nvram_data"); 446 auto define_callback = [](const DefineSpaceReply& reply) { 447 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 448 }; 449 auto write_callback = [](const WriteSpaceReply& reply) { 450 EXPECT_EQ(NVRAM_RESULT_INVALID_PARAMETER, reply.result()); 451 }; 452 DefineSpaceRequest define_request; 453 define_request.set_index(nvram_index); 454 define_request.set_size(nvram_data.size() - 1); 455 service_->DefineSpace(define_request, base::Bind(define_callback)); 456 WriteSpaceRequest write_request; 457 write_request.set_index(nvram_index); 458 write_request.set_data(nvram_data); 459 service_->WriteSpace(write_request, base::Bind(write_callback)); 460 RunServiceWorkerAndQuit(); 461 } 462 463 TEST_F(TpmManagerServiceTest, WriteBeforeAfterLock) { 464 uint32_t nvram_index = 5; 465 std::string nvram_data("nvram_data"); 466 auto define_callback = [](const DefineSpaceReply& reply) { 467 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 468 }; 469 auto write_callback_success = [](const WriteSpaceReply& reply) { 470 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 471 }; 472 auto lock_callback = [](const LockSpaceReply& reply) { 473 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 474 }; 475 auto write_callback_failure = [](const WriteSpaceReply& reply) { 476 EXPECT_EQ(NVRAM_RESULT_OPERATION_DISABLED, reply.result()); 477 }; 478 DefineSpaceRequest define_request; 479 define_request.set_index(nvram_index); 480 define_request.set_size(nvram_data.size()); 481 service_->DefineSpace(define_request, base::Bind(define_callback)); 482 WriteSpaceRequest write_request; 483 write_request.set_index(nvram_index); 484 write_request.set_data(nvram_data); 485 service_->WriteSpace(write_request, base::Bind(write_callback_success)); 486 LockSpaceRequest lock_request; 487 lock_request.set_index(nvram_index); 488 lock_request.set_lock_write(true); 489 service_->LockSpace(lock_request, base::Bind(lock_callback)); 490 service_->WriteSpace(write_request, base::Bind(write_callback_failure)); 491 RunServiceWorkerAndQuit(); 492 } 493 494 TEST_F(TpmManagerServiceTest, ReadUninitializedNvram) { 495 auto callback = [](decltype(this) test, const ReadSpaceReply& reply) { 496 EXPECT_EQ(NVRAM_RESULT_SPACE_DOES_NOT_EXIST, reply.result()); 497 test->Quit(); 498 }; 499 ReadSpaceRequest request; 500 service_->ReadSpace(request, base::Bind(callback, base::Unretained(this))); 501 Run(); 502 } 503 504 TEST_F(TpmManagerServiceTest, ReadWriteSpaceSuccess) { 505 uint32_t nvram_index = 5; 506 std::string nvram_data("nvram_data"); 507 auto define_callback = [](const DefineSpaceReply& reply) { 508 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 509 }; 510 auto write_callback = [](const WriteSpaceReply& reply) { 511 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 512 }; 513 auto read_callback = [](const std::string& nvram_data, 514 const ReadSpaceReply& reply) { 515 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result()); 516 EXPECT_EQ(nvram_data, reply.data()); 517 }; 518 DefineSpaceRequest define_request; 519 define_request.set_index(nvram_index); 520 define_request.set_size(nvram_data.size()); 521 service_->DefineSpace(define_request, base::Bind(define_callback)); 522 WriteSpaceRequest write_request; 523 write_request.set_index(nvram_index); 524 write_request.set_data(nvram_data); 525 service_->WriteSpace(write_request, base::Bind(write_callback)); 526 ReadSpaceRequest read_request; 527 read_request.set_index(nvram_index); 528 service_->ReadSpace(read_request, base::Bind(read_callback, nvram_data)); 529 RunServiceWorkerAndQuit(); 530 } 531 532 } // namespace tpm_manager 533