// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chaps/chaps_service.h"

#include <string>
#include <vector>

#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "chaps/isolate.h"
#include "chaps/object_mock.h"
#include "chaps/session_mock.h"
#include "chaps/slot_manager_mock.h"

using std::string;
using std::vector;
using brillo::SecureBlob;
using ::testing::_;
using ::testing::AnyNumber;
using ::testing::Return;
using ::testing::SetArgumentPointee;

namespace chaps {

// Invalid initialization test.
TEST(InitDeathTest, InvalidInit) {
  ChapsServiceImpl service(NULL);
  EXPECT_DEATH_IF_SUPPORTED(service.Init(), "Check failed");
}

// Test fixture for an initialized service instance.
class TestService : public ::testing::Test {
 protected:
  virtual void SetUp() {
    service_.reset(new ChapsServiceImpl(&slot_manager_));
    ASSERT_TRUE(service_->Init());
    // Setup parsable and un-parsable serialized attributes.
    CK_ATTRIBUTE attributes[] = {{CKA_VALUE, nullptr, 0}};
    CK_ATTRIBUTE attributes2[] = {{CKA_VALUE, const_cast<char*>("test"), 4}};
    attribute_ = attributes[0];
    attribute2_ = attributes2[0];
    Attributes tmp(attributes, 1);
    tmp.Serialize(&good_attributes_);
    Attributes tmp2(attributes2, 1);
    tmp2.Serialize(&good_attributes2_);
    bad_attributes_ = vector<uint8_t>(100, 0xAA);
    ic_ = IsolateCredentialManager::GetDefaultIsolateCredential();
  }
  virtual void TearDown() {
    service_->TearDown();
  }
  SlotManagerMock slot_manager_;
  SessionMock session_;
  ObjectMock object_;
  scoped_ptr<ChapsServiceImpl> service_;
  vector<uint8_t> bad_attributes_;
  vector<uint8_t> good_attributes_;
  vector<uint8_t> good_attributes2_;
  CK_ATTRIBUTE attribute_;
  CK_ATTRIBUTE attribute2_;
  SecureBlob ic_;
};

TEST_F(TestService, GetSlotList) {
  EXPECT_CALL(slot_manager_, GetSlotCount())
    .WillRepeatedly(Return(2));
  EXPECT_CALL(slot_manager_, IsTokenAccessible(ic_, _))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, IsTokenPresent(ic_, _))
    .WillRepeatedly(Return(false));
  // Try bad arguments.
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->GetSlotList(ic_, false, NULL));
  vector<uint64_t> slot_list;
  slot_list.push_back(0);
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->GetSlotList(ic_, false, &slot_list));
  // Try normal use cases.
  slot_list.clear();
  EXPECT_EQ(CKR_OK, service_->GetSlotList(ic_, true, &slot_list));
  EXPECT_EQ(0, slot_list.size());
  EXPECT_EQ(CKR_OK, service_->GetSlotList(ic_, false, &slot_list));
  EXPECT_EQ(2, slot_list.size());

  // Check that when tokens are not accessible to an isolate, the slot list is
  // filtered.
  EXPECT_CALL(slot_manager_, IsTokenAccessible(ic_, _))
    .WillOnce(Return(true))
    .WillOnce(Return(false));
  slot_list.clear();
  EXPECT_EQ(CKR_OK, service_->GetSlotList(ic_, false, &slot_list));
  EXPECT_EQ(1, slot_list.size());
}

TEST_F(TestService, GetSlotInfo) {
  CK_SLOT_INFO test_info;
  memset(&test_info, 0, sizeof(CK_SLOT_INFO));
  test_info.flags = 17;
  EXPECT_CALL(slot_manager_, GetSlotCount())
    .WillRepeatedly(Return(2));
  EXPECT_CALL(slot_manager_, IsTokenAccessible(ic_, _))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, GetSlotInfo(ic_, 0, _))
    .WillRepeatedly(SetArgumentPointee<2>(test_info));

  // Try bad arguments.
  void* p[7];
  for (int i = 0; i < 7; ++i) {
    memset(p, 1, sizeof(p));
    p[i] = NULL;
    EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->GetSlotInfo(
        ic_,
        0,
        reinterpret_cast<vector<uint8_t>*>(p[0]),
        reinterpret_cast<vector<uint8_t>*>(p[1]),
        reinterpret_cast<uint64_t*>(p[2]),
        reinterpret_cast<uint8_t*>(p[3]),
        reinterpret_cast<uint8_t*>(p[4]),
        reinterpret_cast<uint8_t*>(p[5]),
        reinterpret_cast<uint8_t*>(p[6])));
  }
  vector<uint8_t> slot_description;
  vector<uint8_t> manufacturer_id;
  uint64_t flags;
  uint8_t hardware_version_major;
  uint8_t hardware_version_minor;
  uint8_t firmware_version_major;
  uint8_t firmware_version_minor;
  // Try invalid slot ID.
  EXPECT_EQ(CKR_SLOT_ID_INVALID,
            service_->GetSlotInfo(ic_,
                                  2,
                                  &slot_description,
                                  &manufacturer_id,
                                  &flags,
                                  &hardware_version_major,
                                  &hardware_version_minor,
                                  &firmware_version_major,
                                  &firmware_version_minor));
  // Try the normal case.
  EXPECT_EQ(CKR_OK, service_->GetSlotInfo(ic_,
                                          0,
                                          &slot_description,
                                          &manufacturer_id,
                                          &flags,
                                          &hardware_version_major,
                                          &hardware_version_minor,
                                          &firmware_version_major,
                                          &firmware_version_minor));
  EXPECT_EQ(flags, 17);
}

TEST_F(TestService, GetTokenInfo) {
  CK_TOKEN_INFO test_info;
  memset(&test_info, 0, sizeof(CK_TOKEN_INFO));
  test_info.flags = 17;
  EXPECT_CALL(slot_manager_, GetSlotCount())
    .WillRepeatedly(Return(2));
  EXPECT_CALL(slot_manager_, IsTokenAccessible(ic_, _))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, IsTokenPresent(ic_, _))
    .WillOnce(Return(false))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, GetTokenInfo(ic_, 0, _))
    .WillRepeatedly(SetArgumentPointee<2>(test_info));

  // Try bad arguments.
  void* p[19];
  for (int i = 0; i < 19; ++i) {
    memset(p, 1, sizeof(p));
    p[i] = NULL;
    EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->GetTokenInfo(
        ic_,
        0,
        reinterpret_cast<vector<uint8_t>*>(p[0]),
        reinterpret_cast<vector<uint8_t>*>(p[1]),
        reinterpret_cast<vector<uint8_t>*>(p[2]),
        reinterpret_cast<vector<uint8_t>*>(p[3]),
        reinterpret_cast<uint64_t*>(p[4]),
        reinterpret_cast<uint64_t*>(p[5]),
        reinterpret_cast<uint64_t*>(p[6]),
        reinterpret_cast<uint64_t*>(p[7]),
        reinterpret_cast<uint64_t*>(p[8]),
        reinterpret_cast<uint64_t*>(p[9]),
        reinterpret_cast<uint64_t*>(p[10]),
        reinterpret_cast<uint64_t*>(p[11]),
        reinterpret_cast<uint64_t*>(p[12]),
        reinterpret_cast<uint64_t*>(p[13]),
        reinterpret_cast<uint64_t*>(p[14]),
        reinterpret_cast<uint8_t*>(p[15]),
        reinterpret_cast<uint8_t*>(p[16]),
        reinterpret_cast<uint8_t*>(p[17]),
        reinterpret_cast<uint8_t*>(p[18])));
  }
  vector<uint8_t> label;
  vector<uint8_t> manufacturer_id;
  vector<uint8_t> model;
  vector<uint8_t> serial_number;
  uint64_t flags;
  uint64_t max_session_count;
  uint64_t session_count;
  uint64_t max_session_count_rw;
  uint64_t session_count_rw;
  uint64_t max_pin_len;
  uint64_t min_pin_len;
  uint64_t total_public_memory;
  uint64_t free_public_memory;
  uint64_t total_private_memory;
  uint64_t free_private_memory;
  uint8_t hardware_version_major;
  uint8_t hardware_version_minor;
  uint8_t firmware_version_major;
  uint8_t firmware_version_minor;
  // Try invalid slot ID.
  EXPECT_EQ(CKR_SLOT_ID_INVALID,
            service_->GetTokenInfo(ic_,
                                   3,
                                   &label,
                                   &manufacturer_id,
                                   &model,
                                   &serial_number,
                                   &flags,
                                   &max_session_count,
                                   &session_count,
                                   &max_session_count_rw,
                                   &session_count_rw,
                                   &max_pin_len,
                                   &min_pin_len,
                                   &total_public_memory,
                                   &free_public_memory,
                                   &total_private_memory,
                                   &free_private_memory,
                                   &hardware_version_major,
                                   &hardware_version_minor,
                                   &firmware_version_major,
                                   &firmware_version_minor));
  EXPECT_EQ(CKR_TOKEN_NOT_PRESENT,
            service_->GetTokenInfo(ic_,
                                   0,
                                   &label,
                                   &manufacturer_id,
                                   &model,
                                   &serial_number,
                                   &flags,
                                   &max_session_count,
                                   &session_count,
                                   &max_session_count_rw,
                                   &session_count_rw,
                                   &max_pin_len,
                                   &min_pin_len,
                                   &total_public_memory,
                                   &free_public_memory,
                                   &total_private_memory,
                                   &free_private_memory,
                                   &hardware_version_major,
                                   &hardware_version_minor,
                                   &firmware_version_major,
                                   &firmware_version_minor));
  // Try the normal case.
  EXPECT_EQ(CKR_OK, service_->GetTokenInfo(ic_,
                                           0,
                                           &label,
                                           &manufacturer_id,
                                           &model,
                                           &serial_number,
                                           &flags,
                                           &max_session_count,
                                           &session_count,
                                           &max_session_count_rw,
                                           &session_count_rw,
                                           &max_pin_len,
                                           &min_pin_len,
                                           &total_public_memory,
                                           &free_public_memory,
                                           &total_private_memory,
                                           &free_private_memory,
                                           &hardware_version_major,
                                           &hardware_version_minor,
                                           &firmware_version_major,
                                           &firmware_version_minor));
  EXPECT_EQ(flags, 17);
}

TEST_F(TestService, GetMechanismList) {
  MechanismMap test_list;
  CK_MECHANISM_INFO test_info;
  memset(&test_info, 0, sizeof(CK_MECHANISM_INFO));
  test_list[123UL] = test_info;
  EXPECT_CALL(slot_manager_, GetSlotCount())
    .WillRepeatedly(Return(2));
  EXPECT_CALL(slot_manager_, IsTokenAccessible(ic_, _))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, IsTokenPresent(ic_, _))
    .WillOnce(Return(false))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, GetMechanismInfo(ic_, 0))
    .WillRepeatedly(Return(&test_list));
  // Try bad arguments.
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->GetMechanismList(ic_, 0, NULL));
  // Try invalid slot ID.
  vector<uint64_t> output;
  EXPECT_EQ(CKR_SLOT_ID_INVALID, service_->GetMechanismList(ic_, 2, &output));
  EXPECT_EQ(CKR_TOKEN_NOT_PRESENT, service_->GetMechanismList(ic_, 0, &output));
  // Try the normal case.
  ASSERT_EQ(CKR_OK, service_->GetMechanismList(ic_, 0, &output));
  ASSERT_EQ(output.size(), 1);
  EXPECT_EQ(output[0], 123);
}

TEST_F(TestService, GetMechanismInfo) {
  MechanismMap test_list;
  CK_MECHANISM_INFO test_info;
  memset(&test_info, 0, sizeof(CK_MECHANISM_INFO));
  test_info.flags = 17;
  test_list[123UL] = test_info;
  EXPECT_CALL(slot_manager_, GetSlotCount())
    .WillRepeatedly(Return(2));
  EXPECT_CALL(slot_manager_, IsTokenAccessible(ic_, _))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, IsTokenPresent(ic_, _))
    .WillOnce(Return(false))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, GetMechanismInfo(ic_, 0))
    .WillRepeatedly(Return(&test_list));
  uint64_t min_key, max_key, flags;
  // Try bad arguments.
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->GetMechanismInfo(ic_, 0, 123, NULL, &max_key, &flags));
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->GetMechanismInfo(ic_, 0, 123, &min_key, NULL, &flags));
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->GetMechanismInfo(ic_, 0, 123, &min_key, &max_key, NULL));
  // Try invalid slot ID.
  EXPECT_EQ(CKR_SLOT_ID_INVALID,
            service_->GetMechanismInfo(ic_, 2, 123, &min_key, &max_key,
                                       &flags));
  EXPECT_EQ(CKR_TOKEN_NOT_PRESENT,
            service_->GetMechanismInfo(ic_, 0, 123, &min_key, &max_key,
                                       &flags));
  // Try the normal case.
  ASSERT_EQ(CKR_OK,
            service_->GetMechanismInfo(ic_, 0, 123, &min_key, &max_key,
                                       &flags));
  EXPECT_EQ(flags, 17);
}

TEST_F(TestService, InitToken) {
  EXPECT_CALL(slot_manager_, GetSlotCount())
    .WillRepeatedly(Return(2));
  EXPECT_CALL(slot_manager_, IsTokenAccessible(ic_, _))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, IsTokenPresent(ic_, _))
    .WillOnce(Return(false))
    .WillOnce(Return(true));
  vector<uint8_t> bad_label;
  vector<uint8_t> good_label(chaps::kTokenLabelSize, 0x20);
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->InitToken(ic_, 0, NULL, bad_label));
  EXPECT_EQ(CKR_SLOT_ID_INVALID, service_->InitToken(ic_, 2, NULL, good_label));
  EXPECT_EQ(CKR_TOKEN_NOT_PRESENT, service_->InitToken(ic_, 0, NULL,
                                                       good_label));
  EXPECT_EQ(CKR_PIN_INCORRECT, service_->InitToken(ic_, 0, NULL, good_label));
}

TEST_F(TestService, InitPIN) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 0, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->InitPIN(ic_, 0, NULL));
  EXPECT_EQ(CKR_USER_NOT_LOGGED_IN, service_->InitPIN(ic_, 0, NULL));
}

TEST_F(TestService, SetPIN) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 0, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->SetPIN(ic_, 0, NULL, NULL));
  EXPECT_EQ(CKR_PIN_INVALID, service_->SetPIN(ic_, 0, NULL, NULL));
}

TEST_F(TestService, OpenSession) {
  EXPECT_CALL(slot_manager_, GetSlotCount())
    .WillRepeatedly(Return(2));
  EXPECT_CALL(slot_manager_, IsTokenAccessible(ic_, _))
    .WillOnce(Return(false))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, IsTokenPresent(ic_, _))
    .WillOnce(Return(false))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, OpenSession(ic_, 0, true))
    .WillRepeatedly(Return(10));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->OpenSession(ic_, 0, 0, NULL));
  uint64_t session;
  EXPECT_EQ(CKR_SLOT_ID_INVALID, service_->OpenSession(ic_, 2, 0, &session));
  EXPECT_EQ(CKR_SLOT_ID_INVALID, service_->OpenSession(ic_, 0, 0, &session));
  EXPECT_EQ(CKR_TOKEN_NOT_PRESENT, service_->OpenSession(ic_, 0, 0, &session));
  EXPECT_EQ(CKR_SESSION_PARALLEL_NOT_SUPPORTED,
            service_->OpenSession(ic_, 0, 0, &session));
  ASSERT_EQ(CKR_OK, service_->OpenSession(ic_, 0, CKF_SERIAL_SESSION,
                                          &session));
  EXPECT_EQ(session, 10);
}

TEST_F(TestService, CloseSession) {
  EXPECT_CALL(slot_manager_, CloseSession(ic_, 0))
    .WillOnce(Return(false))
    .WillOnce(Return(true));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->CloseSession(ic_, 0));
  EXPECT_EQ(CKR_OK, service_->CloseSession(ic_, 0));
}

TEST_F(TestService, CloseAllSessions) {
  EXPECT_CALL(slot_manager_, GetSlotCount())
    .WillRepeatedly(Return(2));
  EXPECT_CALL(slot_manager_, IsTokenAccessible(ic_, _))
    .WillOnce(Return(false))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, IsTokenPresent(ic_, _))
    .WillOnce(Return(false))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(slot_manager_, CloseAllSessions(ic_, 1));
  EXPECT_EQ(CKR_SLOT_ID_INVALID, service_->CloseAllSessions(ic_, 2));
  EXPECT_EQ(CKR_SLOT_ID_INVALID, service_->CloseAllSessions(ic_, 1));
  EXPECT_EQ(CKR_TOKEN_NOT_PRESENT, service_->CloseAllSessions(ic_, 1));
  EXPECT_EQ(CKR_OK, service_->CloseAllSessions(ic_, 1));
}

TEST_F(TestService, GetSessionInfo) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, GetSlot())
    .WillRepeatedly(Return(15));
  EXPECT_CALL(session_, GetState())
    .WillRepeatedly(Return(16));
  EXPECT_CALL(session_, IsReadOnly())
    .WillRepeatedly(Return(false));
  // Try bad arguments.
  uint64_t slot, state, flags, err;
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->GetSessionInfo(ic_, 1, NULL, &state, &flags, &err));
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->GetSessionInfo(ic_, 1, &slot, NULL, &flags, &err));
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->GetSessionInfo(ic_, 1, &slot, &state, NULL, &err));
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->GetSessionInfo(ic_, 1, &slot, &state, &flags, NULL));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->GetSessionInfo(ic_, 1, &slot, &state, &flags, &err));
  // Try normal case.
  ASSERT_EQ(CKR_OK, service_->GetSessionInfo(ic_, 1, &slot, &state, &flags,
                                             &err));
  EXPECT_EQ(slot, 15);
  EXPECT_EQ(state, 16);
  EXPECT_EQ(flags, CKF_RW_SESSION|CKF_SERIAL_SESSION);
}

TEST_F(TestService, GetOperationState) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, IsOperationActive(_))
    .WillRepeatedly(Return(false));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->GetOperationState(ic_, 1, NULL));
  vector<uint8_t> state;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->GetOperationState(ic_, 1, &state));
  EXPECT_EQ(CKR_OPERATION_NOT_INITIALIZED,
            service_->GetOperationState(ic_, 1, &state));
  EXPECT_CALL(session_, IsOperationActive(_))
    .WillRepeatedly(Return(true));
  EXPECT_EQ(CKR_STATE_UNSAVEABLE,
            service_->GetOperationState(ic_, 1, &state));
}

TEST_F(TestService, SetOperationState) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  vector<uint8_t> state;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->SetOperationState(ic_, 1, state, 0, 0));
  EXPECT_EQ(CKR_SAVED_STATE_INVALID,
            service_->SetOperationState(ic_, 1, state, 0, 0));
}

TEST_F(TestService, Login) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, WaitForPrivateObjects()).Times(AnyNumber());
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->Login(ic_, 1, CKU_USER, NULL));
  string bad_pin("1234");
  string good_pin("111111");
  EXPECT_EQ(CKR_PIN_INCORRECT, service_->Login(ic_, 1, CKU_SO, &good_pin));
  EXPECT_EQ(CKR_PIN_INCORRECT, service_->Login(ic_, 1, CKU_USER, &bad_pin));
  EXPECT_EQ(CKR_OK, service_->Login(ic_, 1, CKU_USER, &good_pin));
  EXPECT_EQ(CKR_OK, service_->Login(ic_, 1, CKU_USER, NULL));
}

TEST_F(TestService, Logout) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->Logout(ic_, 1));
  EXPECT_EQ(CKR_OK, service_->Logout(ic_, 1));
}

TEST_F(TestService, CreateObject) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, CreateObject(_, 1, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(2), Return(CKR_OK)));
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->CreateObject(ic_, 1, good_attributes_, NULL));
  uint64_t object_handle;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->CreateObject(ic_, 1, good_attributes_, &object_handle));
  EXPECT_EQ(CKR_TEMPLATE_INCONSISTENT,
            service_->CreateObject(ic_, 1, bad_attributes_, &object_handle));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->CreateObject(ic_, 1, good_attributes_, &object_handle));
  EXPECT_EQ(CKR_OK,
            service_->CreateObject(ic_, 1, good_attributes_, &object_handle));
  EXPECT_EQ(object_handle, 2);
}

TEST_F(TestService, CopyObject) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, CopyObject(_, 1, 2, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<3>(3), Return(CKR_OK)));
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->CopyObject(ic_, 1, 2, good_attributes_, NULL));
  uint64_t object_handle;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->CopyObject(ic_, 1, 2, good_attributes_, &object_handle));
  EXPECT_EQ(CKR_TEMPLATE_INCONSISTENT,
            service_->CopyObject(ic_, 1, 2, bad_attributes_, &object_handle));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->CopyObject(ic_, 1, 2, good_attributes_, &object_handle));
  EXPECT_EQ(CKR_OK,
            service_->CopyObject(ic_, 1, 2, good_attributes_, &object_handle));
  EXPECT_EQ(object_handle, 3);
}

TEST_F(TestService, DestroyObject) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, DestroyObject(_))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->DestroyObject(ic_, 1, 2));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->DestroyObject(ic_, 1, 2));
  EXPECT_EQ(CKR_OK, service_->DestroyObject(ic_, 1, 2));
}

TEST_F(TestService, GetObjectSize) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, GetObject(2, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(&object_), Return(true)));
  EXPECT_CALL(object_, GetSize())
    .WillRepeatedly(Return(3));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->GetObjectSize(ic_, 1, 2, NULL));
  uint64_t size = 0;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->GetObjectSize(ic_, 1, 2,
                                                                &size));
  EXPECT_EQ(CKR_OBJECT_HANDLE_INVALID, service_->GetObjectSize(ic_, 1, 2,
                                                               &size));
  EXPECT_EQ(CKR_OK, service_->GetObjectSize(ic_, 1, 2, &size));
  EXPECT_EQ(size, 3);
}

TEST_F(TestService, GetAttributeValue) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, GetObject(2, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(&object_), Return(true)));
  EXPECT_CALL(object_, GetAttributes(_, 1))
    .WillOnce(Return(CKR_TEMPLATE_INCONSISTENT))
    .WillOnce(Return(CKR_ATTRIBUTE_SENSITIVE))
    .WillOnce(Return(CKR_ATTRIBUTE_TYPE_INVALID))
    .WillRepeatedly(Return(CKR_OK));
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->GetAttributeValue(ic_, 1, 2, good_attributes_, NULL));
  vector<uint8_t> output;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->GetAttributeValue(ic_, 1, 2, good_attributes_, &output));
  EXPECT_EQ(CKR_OBJECT_HANDLE_INVALID,
            service_->GetAttributeValue(ic_, 1, 2, good_attributes_, &output));
  EXPECT_EQ(CKR_TEMPLATE_INCONSISTENT,
            service_->GetAttributeValue(ic_, 1, 2, bad_attributes_, &output));
  EXPECT_EQ(CKR_TEMPLATE_INCONSISTENT,
            service_->GetAttributeValue(ic_, 1, 2, good_attributes_, &output));
  EXPECT_EQ(output.size(), 0);
  EXPECT_EQ(CKR_ATTRIBUTE_SENSITIVE,
            service_->GetAttributeValue(ic_, 1, 2, good_attributes_, &output));

  // Construct a template with a valid pointer to test serialization when the
  // mock returns CKR_ATTRIBUTE_TYPE_INVALID.
  int out_value = 1234;
  CK_ATTRIBUTE invalid_type = {0, &out_value, ~0UL};
  Attributes tmp(&invalid_type, 1);
  vector<uint8_t> tmp_serialized;
  tmp.Serialize(&tmp_serialized);
  EXPECT_EQ(CKR_ATTRIBUTE_TYPE_INVALID,
            service_->GetAttributeValue(ic_, 1, 2, tmp_serialized, &output));
  EXPECT_EQ(CKR_OK,
            service_->GetAttributeValue(ic_, 1, 2, good_attributes_, &output));
}

TEST_F(TestService, SetAttributeValue) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, GetModifiableObject(2, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(&object_), Return(true)));
  EXPECT_CALL(session_, FlushModifiableObject(_))
    .WillOnce(Return(false))
    .WillRepeatedly(Return(true));
  EXPECT_CALL(object_, SetAttributes(_, 1))
    .WillOnce(Return(CKR_TEMPLATE_INCONSISTENT))
    .WillRepeatedly(Return(CKR_OK));
  vector<uint8_t> output;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->SetAttributeValue(ic_, 1, 2, good_attributes_));
  EXPECT_EQ(CKR_OBJECT_HANDLE_INVALID,
            service_->SetAttributeValue(ic_, 1, 2, good_attributes_));
  EXPECT_EQ(CKR_TEMPLATE_INCONSISTENT,
            service_->SetAttributeValue(ic_, 1, 2, bad_attributes_));
  EXPECT_EQ(CKR_TEMPLATE_INCONSISTENT,
            service_->SetAttributeValue(ic_, 1, 2, good_attributes_));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->SetAttributeValue(ic_, 1, 2, good_attributes_));
  EXPECT_EQ(CKR_OK, service_->SetAttributeValue(ic_, 1, 2, good_attributes_));
}

TEST_F(TestService, FindObjectsInit) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, FindObjectsInit(_, 1))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->FindObjectsInit(ic_, 1, good_attributes_));
  EXPECT_EQ(CKR_TEMPLATE_INCONSISTENT,
            service_->FindObjectsInit(ic_, 1, bad_attributes_));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->FindObjectsInit(ic_, 1, good_attributes_));
  EXPECT_EQ(CKR_OK, service_->FindObjectsInit(ic_, 1, good_attributes_));
}

TEST_F(TestService, FindObjects) {
  vector<uint64_t> objects_ret(12, 12);
  vector<int> objects_mock(12, 12);
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, FindObjects(2, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(objects_mock), Return(CKR_OK)));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->FindObjects(ic_, 1, 2, NULL));
  vector<uint64_t> objects(1, 1);
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->FindObjects(ic_, 1, 2, &objects));
  objects.clear();
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->FindObjects(ic_, 1, 2,
                                                              &objects));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->FindObjects(ic_, 1, 2, &objects));
  EXPECT_EQ(CKR_OK, service_->FindObjects(ic_, 1, 2, &objects));
  EXPECT_TRUE(objects == objects_ret);
}

TEST_F(TestService, FindObjectsFinal) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, FindObjectsFinal())
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->FindObjectsFinal(ic_, 1));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->FindObjectsFinal(ic_, 1));
  EXPECT_EQ(CKR_OK, service_->FindObjectsFinal(ic_, 1));
}

TEST_F(TestService, EncryptInit) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, GetObject(3, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(&object_), Return(true)));
  EXPECT_CALL(session_, OperationInit(kEncrypt, 2, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  vector<uint8_t> p(10, 0x10);
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->EncryptInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_KEY_HANDLE_INVALID, service_->EncryptInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->EncryptInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_OK, service_->EncryptInit(ic_, 1, 2, p, 3));
}

TEST_F(TestService, Encrypt) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationSinglePart(kEncrypt, _, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(7), Return(CKR_OK)));
  vector<uint8_t> data;
  uint64_t len = 0;
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->Encrypt(ic_, 1, data, 2, NULL, &data));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->Encrypt(ic_, 1, data, 2, &len, NULL));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->Encrypt(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->Encrypt(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_OK, service_->Encrypt(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(len, 7);
}

TEST_F(TestService, EncryptUpdate) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationUpdate(kEncrypt, _, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(7), Return(CKR_OK)));
  vector<uint8_t> data;
  uint64_t len = 0;
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->EncryptUpdate(ic_, 1, data, 2, NULL, &data));
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->EncryptUpdate(ic_, 1, data, 2, &len, NULL));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->EncryptUpdate(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->EncryptUpdate(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_OK, service_->EncryptUpdate(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(len, 7);
}

TEST_F(TestService, EncryptFinal) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationFinal(kEncrypt, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(7), Return(CKR_OK)));
  vector<uint8_t> data;
  uint64_t len = 0;
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->EncryptFinal(ic_, 1, 2, NULL, &data));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->EncryptFinal(ic_, 1, 2, &len, NULL));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->EncryptFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->EncryptFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(CKR_OK, service_->EncryptFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(len, 7);
}

TEST_F(TestService, DecryptInit) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, GetObject(3, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(&object_), Return(true)));
  EXPECT_CALL(session_, OperationInit(kDecrypt, 2, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  vector<uint8_t> p(10, 0x10);
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->DecryptInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_KEY_HANDLE_INVALID, service_->DecryptInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->DecryptInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_OK, service_->DecryptInit(ic_, 1, 2, p, 3));
}

TEST_F(TestService, Decrypt) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationSinglePart(kDecrypt, _, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(7), Return(CKR_OK)));
  vector<uint8_t> data;
  uint64_t len = 0;
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->Decrypt(ic_, 1, data, 2, NULL, &data));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->Decrypt(ic_, 1, data, 2, &len, NULL));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->Decrypt(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->Decrypt(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_OK, service_->Decrypt(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(len, 7);
}

TEST_F(TestService, DecryptUpdate) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationUpdate(kDecrypt, _, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(7), Return(CKR_OK)));
  vector<uint8_t> data;
  uint64_t len = 0;
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->DecryptUpdate(ic_, 1, data, 2, NULL, &data));
  EXPECT_EQ(CKR_ARGUMENTS_BAD,
            service_->DecryptUpdate(ic_, 1, data, 2, &len, NULL));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->DecryptUpdate(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->DecryptUpdate(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_OK, service_->DecryptUpdate(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(len, 7);
}

TEST_F(TestService, DecryptFinal) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationFinal(kDecrypt, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(7), Return(CKR_OK)));
  vector<uint8_t> data;
  uint64_t len = 0;
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->DecryptFinal(ic_, 1, 2, NULL, &data));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->DecryptFinal(ic_, 1, 2, &len, NULL));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->DecryptFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->DecryptFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(CKR_OK, service_->DecryptFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(len, 7);
}

TEST_F(TestService, DigestInit) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationInit(kDigest, 2, _, NULL))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  vector<uint8_t> p(10, 0x10);
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->DigestInit(ic_, 1, 2, p));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->DigestInit(ic_, 1, 2, p));
  EXPECT_EQ(CKR_OK, service_->DigestInit(ic_, 1, 2, p));
}

TEST_F(TestService, Digest) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationSinglePart(kDigest, _, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(7), Return(CKR_OK)));
  vector<uint8_t> data;
  uint64_t len = 0;
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->Digest(ic_, 1, data, 2, NULL, &data));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->Digest(ic_, 1, data, 2, &len, NULL));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->Digest(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->Digest(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_OK, service_->Digest(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(len, 7);
}

TEST_F(TestService, DigestUpdate) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationUpdate(kDigest, _, NULL, NULL))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  vector<uint8_t> data;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->DigestUpdate(ic_, 1, data));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->DigestUpdate(ic_, 1, data));
  EXPECT_EQ(CKR_OK, service_->DigestUpdate(ic_, 1, data));
}

TEST_F(TestService, DigestFinal) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationFinal(kDigest, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(7), Return(CKR_OK)));
  vector<uint8_t> data;
  uint64_t len = 0;
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->DigestFinal(ic_, 1, 2, NULL, &data));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->DigestFinal(ic_, 1, 2, &len, NULL));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->DigestFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->DigestFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(CKR_OK, service_->DigestFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(len, 7);
}

TEST_F(TestService, SignInit) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, GetObject(3, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(&object_), Return(true)));
  EXPECT_CALL(session_, OperationInit(kSign, 2, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  vector<uint8_t> p(10, 0x10);
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->SignInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_KEY_HANDLE_INVALID, service_->SignInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->SignInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_OK, service_->SignInit(ic_, 1, 2, p, 3));
}

TEST_F(TestService, Sign) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationSinglePart(kSign, _, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(7), Return(CKR_OK)));
  vector<uint8_t> data;
  uint64_t len = 0;
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->Sign(ic_, 1, data, 2, NULL, &data));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->Sign(ic_, 1, data, 2, &len, NULL));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->Sign(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->Sign(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(CKR_OK, service_->Sign(ic_, 1, data, 2, &len, &data));
  EXPECT_EQ(len, 7);
}

TEST_F(TestService, SignUpdate) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationUpdate(kSign, _, NULL, NULL))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  vector<uint8_t> data;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->SignUpdate(ic_, 1, data));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->SignUpdate(ic_, 1, data));
  EXPECT_EQ(CKR_OK, service_->SignUpdate(ic_, 1, data));
}

TEST_F(TestService, SignFinal) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationFinal(kSign, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(7), Return(CKR_OK)));
  vector<uint8_t> data;
  uint64_t len = 0;
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->SignFinal(ic_, 1, 2, NULL, &data));
  EXPECT_EQ(CKR_ARGUMENTS_BAD, service_->SignFinal(ic_, 1, 2, &len, NULL));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->SignFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->SignFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(CKR_OK, service_->SignFinal(ic_, 1, 2, &len, &data));
  EXPECT_EQ(len, 7);
}

TEST_F(TestService, VerifyInit) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, GetObject(3, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(&object_), Return(true)));
  EXPECT_CALL(session_, OperationInit(kVerify, 2, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  vector<uint8_t> p(10, 0x10);
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->VerifyInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_KEY_HANDLE_INVALID, service_->VerifyInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->VerifyInit(ic_, 1, 2, p, 3));
  EXPECT_EQ(CKR_OK, service_->VerifyInit(ic_, 1, 2, p, 3));
}

TEST_F(TestService, Verify) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationUpdate(kVerify, _, NULL, NULL))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  EXPECT_CALL(session_, VerifyFinal(_))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  vector<uint8_t> data;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->Verify(ic_, 1, data, data));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->Verify(ic_, 1, data, data));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->Verify(ic_, 1, data, data));
  EXPECT_EQ(CKR_OK, service_->Verify(ic_, 1, data, data));
}

TEST_F(TestService, VerifyUpdate) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, OperationUpdate(kVerify, _, NULL, NULL))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  vector<uint8_t> data;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->VerifyUpdate(ic_, 1, data));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->VerifyUpdate(ic_, 1, data));
  EXPECT_EQ(CKR_OK, service_->VerifyUpdate(ic_, 1, data));
}

TEST_F(TestService, VerifyFinal) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, VerifyFinal(_))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(Return(CKR_OK));
  vector<uint8_t> data;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->VerifyFinal(ic_, 1, data));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->VerifyFinal(ic_, 1, data));
  EXPECT_EQ(CKR_OK, service_->VerifyFinal(ic_, 1, data));
}

TEST_F(TestService, GenerateKey) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, GenerateKey(2, _, _, 1, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<4>(3), Return(CKR_OK)));
  vector<uint8_t> param;
  uint64_t handle;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->GenerateKey(ic_, 1, 2, param, good_attributes_, &handle));
  EXPECT_EQ(CKR_TEMPLATE_INCONSISTENT,
            service_->GenerateKey(ic_, 1, 2, param, bad_attributes_, &handle));
  EXPECT_EQ(CKR_FUNCTION_FAILED,
            service_->GenerateKey(ic_, 1, 2, param, good_attributes_, &handle));
  EXPECT_EQ(CKR_OK,
            service_->GenerateKey(ic_, 1, 2, param, good_attributes_, &handle));
  EXPECT_EQ(handle, 3);
}

TEST_F(TestService, GenerateKeyPair) {
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, GenerateKeyPair(2, _, _, 1, _, 1, _, _))
    .WillOnce(Return(CKR_FUNCTION_FAILED))
    .WillRepeatedly(DoAll(SetArgumentPointee<6>(3),
                          SetArgumentPointee<7>(4),
                          Return(CKR_OK)));
  vector<uint8_t> param;
  uint64_t handle[2];
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->GenerateKeyPair(ic_, 1, 2, param,
                                      good_attributes_, good_attributes2_,
                                      &handle[0], &handle[1]));
  EXPECT_EQ(CKR_TEMPLATE_INCONSISTENT,
            service_->GenerateKeyPair(ic_, 1, 2, param,
                                      bad_attributes_, good_attributes2_,
                                      &handle[0], &handle[1]));
  EXPECT_EQ(CKR_TEMPLATE_INCONSISTENT,
            service_->GenerateKeyPair(ic_, 1, 2, param,
                                      good_attributes_, bad_attributes_,
                                      &handle[0], &handle[1]));
  EXPECT_EQ(CKR_FUNCTION_FAILED, service_->GenerateKeyPair(ic_, 1, 2, param,
                                                           good_attributes_,
                                                           good_attributes2_,
                                                           &handle[0],
                                                           &handle[1]));
  EXPECT_EQ(CKR_OK, service_->GenerateKeyPair(ic_, 1, 2, param,
                                              good_attributes_,
                                              good_attributes2_,
                                              &handle[0],
                                              &handle[1]));
  EXPECT_EQ(handle[0], 3);
  EXPECT_EQ(handle[1], 4);
}

TEST_F(TestService, SeedRandom) {
  vector<uint8_t> seed(3, 'A');
  string seed_str("AAA");
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, SeedRandom(seed_str)).WillRepeatedly(Return(CKR_OK));
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID, service_->SeedRandom(ic_, 1, seed));
  EXPECT_EQ(CKR_OK, service_->SeedRandom(ic_, 1, seed));
}

TEST_F(TestService, GenerateRandom) {
  vector<uint8_t> random_data(3, 'B');
  string random_data_str("BBB");
  EXPECT_CALL(slot_manager_, GetSession(ic_, 1, _))
    .WillOnce(Return(false))
    .WillRepeatedly(DoAll(SetArgumentPointee<2>(&session_), Return(true)));
  EXPECT_CALL(session_, GenerateRandom(8, _))
    .WillRepeatedly(DoAll(SetArgumentPointee<1>(random_data_str),
                          Return(CKR_OK)));
  vector<uint8_t> output;
  EXPECT_EQ(CKR_SESSION_HANDLE_INVALID,
            service_->GenerateRandom(ic_, 1, 8, &output));
  EXPECT_EQ(CKR_OK, service_->GenerateRandom(ic_, 1, 8, &output));
  EXPECT_TRUE(output == random_data);
}

}  // namespace chaps

int main(int argc, char** argv) {
  ::testing::InitGoogleMock(&argc, argv);
  return RUN_ALL_TESTS();
}