TEST_F(BlockStoreUtilsTest_CopyToExistingBlock, CopyDataBlock) {
  auto block = blockStore->create(Data(SIZE));
  block->write(dataFixture.data(), 0, SIZE);
  auto block2 = blockStore->create(Data(SIZE));
  copyTo(block2.get(), *block);

  EXPECT_EQ(0, std::memcmp(dataFixture.data(), block2->data(), SIZE));
}

TEST_F(BlockStoreUtilsTest, FillWithZeroes) {
  auto block = blockStore->create(Data(SIZE));
  block->write(dataFixture.data(), 0, SIZE);
  EXPECT_NE(0, std::memcmp(ZEROES.data(), block->data(), SIZE));
  fillWithZeroes(block.get());
  EXPECT_EQ(0, std::memcmp(ZEROES.data(), block->data(), SIZE));
}

TEST_F(ConcreteInnerEncryptorTest, DoesntDecryptWithWrongCipherName) {
    auto encryptor = makeInnerEncryptor<Twofish128_CFB>();
    InnerConfig encrypted = encryptor->encrypt(Data(0));
    encrypted.cipherName = AES256_CFB::NAME;
    auto decrypted = encryptor->decrypt(encrypted);
    EXPECT_EQ(none, decrypted);
}

TEST_F(BlockStoreUtilsTest_CopyToNewBlock, OriginalBlockUnchanged) {
  auto block = blockStore->create(Data(SIZE));
  block->write(dataFixture.data(), 0, SIZE);
  auto block2 = copyToNewBlock(blockStore.get(), *block);

  EXPECT_EQ(SIZE, block->size());
  EXPECT_EQ(0, std::memcmp(dataFixture.data(), block->data(), SIZE));
}

TEST_F(OnDiskBlockCreateTest, CreatingBlockCreatesFile) {
  EXPECT_FALSE(bf::exists(file.path()));

  auto block = OnDiskBlock::CreateOnDisk(dir.path(), key, Data(0));

  EXPECT_TRUE(bf::exists(file.path()));
  EXPECT_TRUE(bf::is_regular_file(file.path()));
}

TEST_F(CryConfigEncryptorFactoryTest, DoesntDecryptWithWrongPassword_EmptyData) {
    auto encryptor = CryConfigEncryptorFactory::deriveKey("mypassword", SCrypt::TestSettings);
    Data encrypted = encryptor->encrypt(Data(0), AES256_GCM::NAME);

    auto loadedEncryptor = CryConfigEncryptorFactory::loadKey(encrypted, "wrongpassword").value();
    auto decrypted = loadedEncryptor->decrypt(encrypted);
    EXPECT_EQ(none, decrypted);
}

TEST_F(CryConfigEncryptorTest, EncryptionIsFixedSize) {
    auto encryptor = makeEncryptor();
    Data encrypted1 = encryptor->encrypt(DataFixture::generate(100), AES128_CFB::NAME);
    Data encrypted2 = encryptor->encrypt(DataFixture::generate(200), Twofish256_GCM::NAME);
    Data encrypted3 = encryptor->encrypt(Data(0), AES256_GCM::NAME);

    EXPECT_EQ(encrypted1.size(), encrypted2.size());
    EXPECT_EQ(encrypted1.size(), encrypted3.size());
}

TEST_F(CachingBlockStoreTest, PhysicalBlockSize_negativeboundaries) {
    // This tests that a potential if/else in blockSizeFromPhysicalBlockSize that catches negative values has the
    // correct boundary set. We test the highest value that is negative and the smallest value that is positive.
    auto physicalSizeForVirtualSizeZero = baseBlockStore->load(CreateBlockReturnKey(Data(0))).value()->size();
    if (physicalSizeForVirtualSizeZero > 0) {
        EXPECT_EQ(0u, blockStore.blockSizeFromPhysicalBlockSize(physicalSizeForVirtualSizeZero - 1));
    }
    EXPECT_EQ(0u, blockStore.blockSizeFromPhysicalBlockSize(physicalSizeForVirtualSizeZero));
    EXPECT_EQ(1u, blockStore.blockSizeFromPhysicalBlockSize(physicalSizeForVirtualSizeZero + 1));
}

TEST_F(CachingBlockStoreTest, PhysicalBlockSize_zerovirtual) {
    auto key = CreateBlockReturnKey(Data(0));
    auto base = baseBlockStore->load(key).value();
    EXPECT_EQ(0u, blockStore.blockSizeFromPhysicalBlockSize(base->size()));
}

 DerivedKey<CryConfigEncryptor::MaxTotalKeySize> _derivedKey() {
     auto salt = DataFixture::generate(128, 2);
     auto keyConfig = DerivedKeyConfig(std::move(salt), 1024, 1, 2);
     auto key = DataFixture::generateFixedSize<CryConfigEncryptor::MaxTotalKeySize>(3);
     return DerivedKey<CryConfigEncryptor::MaxTotalKeySize>(std::move(keyConfig), std::move(key));
 }

 OnDiskBlockCreateSizeTest():
   block(OnDiskBlock::CreateOnDisk(dir.path(), key, std::move(Data(GetParam()).FillWithZeroes())).value()),
   ZEROES(block->size())
 {
   ZEROES.FillWithZeroes();
 }

 blockstore::Key CreateBlockWriteFixtureToItAndReturnKey() {
   auto block = blockStore->create(Data(data.size()));
   block->write(data.data(), 0, data.size());
   return block->key();
 }

TEST_F(OuterConfigTest, SomeValues) {
    Data serialized = OuterConfig{DerivedKeyConfig(salt(), N, r, p), DataFixture::generate(1024)}.serialize();
    OuterConfig deserialized = OuterConfig::deserialize(serialized).value();
    EXPECT_EQ(DerivedKeyConfig(salt(), N, r, p), deserialized.keyConfig);
    EXPECT_EQ(DataFixture::generate(1024), deserialized.encryptedInnerConfig);
}

TEST_F(OuterConfigTest, DataAndKeyConfigEmpty) {
    Data serialized = OuterConfig{DerivedKeyConfig(Data(0), 0, 0, 0), Data(0)}.serialize();
    OuterConfig deserialized = OuterConfig::deserialize(serialized).value();
    EXPECT_EQ(DerivedKeyConfig(Data(0), 0, 0, 0), deserialized.keyConfig);
    EXPECT_EQ(Data(0), deserialized.encryptedInnerConfig);
}

TEST_F(OuterConfigTest, DataAndKeyConfigEmpty) {
    Data serialized = OuterConfig{Data(0), Data(0), false}.serialize();
    OuterConfig deserialized = OuterConfig::deserialize(serialized).value();
    EXPECT_EQ(Data(0), deserialized.kdfParameters);
    EXPECT_EQ(Data(0), deserialized.encryptedInnerConfig);
}