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