Moved //components/proximity_auth/cryptauth to //components/cryptauth.

components/cryptauth/fake_secure_message_delegate_unittest.cc

 // Copyright 2014 The Chromium 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 "components/proximity_auth/cryptauth/fake_secure_message_delegate.h"
+#include "components/cryptauth/fake_secure_message_delegate.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace proximity_auth {
+namespace cryptauth {
 
 namespace {
 
 const char kTestPublicKey[] = "the private key is in another castle";
 const char kPayload[] = "500 tons of uranium";
 const char kSymmetricKey[] = "hunter2";
 const char kPublicMetadata[] = "brought to you by our sponsors";
 const char kAssociatedData[] = "save 20% bytes on your nonce insurance";
 const char kVerificationKeyId[] = "the one with the red stripes";
 const char kDecryptionKeyId[] = "it's in your pocket somewhere";
@@ skipping 60 matching lines @@
   const securemessage::Header& header = header_and_body.header();
   EXPECT_EQ(create_options.signature_scheme, header.signature_scheme());
   EXPECT_EQ(create_options.encryption_scheme, header.encryption_scheme());
   EXPECT_EQ(create_options.verification_key_id, header.verification_key_id());
   EXPECT_EQ(create_options.decryption_key_id, header.decryption_key_id());
   EXPECT_EQ(create_options.public_metadata, header.public_metadata());
 }
 
 }  // namespace
 
-class ProximityAuthFakeSecureMessageDelegateTest : public testing::Test {
+class CryptAuthFakeSecureMessageDelegateTest : public testing::Test {
  protected:
-  ProximityAuthFakeSecureMessageDelegateTest() {}
+  CryptAuthFakeSecureMessageDelegateTest() {}
 
   FakeSecureMessageDelegate delegate_;
 
-  DISALLOW_COPY_AND_ASSIGN(ProximityAuthFakeSecureMessageDelegateTest);
+  DISALLOW_COPY_AND_ASSIGN(CryptAuthFakeSecureMessageDelegateTest);
 };
 
-TEST_F(ProximityAuthFakeSecureMessageDelegateTest, GenerateKeyPair) {
+TEST_F(CryptAuthFakeSecureMessageDelegateTest, GenerateKeyPair) {
   std::string public_key1, private_key1;
   delegate_.GenerateKeyPair(
       base::Bind(&SaveKeyPair, &public_key1, &private_key1));
   EXPECT_NE(private_key1, public_key1);
 
   std::string public_key2, private_key2;
   delegate_.GenerateKeyPair(
       base::Bind(&SaveKeyPair, &public_key2, &private_key2));
   EXPECT_NE(private_key2, public_key2);
 
   EXPECT_NE(public_key1, public_key2);
   EXPECT_NE(private_key1, private_key2);
 
   delegate_.set_next_public_key(kTestPublicKey);
   std::string public_key3, private_key3;
   delegate_.GenerateKeyPair(
       base::Bind(&SaveKeyPair, &public_key3, &private_key3));
   EXPECT_EQ(kTestPublicKey, public_key3);
   EXPECT_NE(private_key3, public_key3);
 
   EXPECT_NE(public_key1, public_key3);
   EXPECT_NE(private_key1, private_key3);
 }
 
-TEST_F(ProximityAuthFakeSecureMessageDelegateTest, DeriveKey) {
+TEST_F(CryptAuthFakeSecureMessageDelegateTest, DeriveKey) {
   delegate_.set_next_public_key("key_pair_1");
   std::string public_key1, private_key1;
   delegate_.GenerateKeyPair(
       base::Bind(&SaveKeyPair, &public_key1, &private_key1));
 
   delegate_.set_next_public_key("key_pair_2");
   std::string public_key2, private_key2;
   delegate_.GenerateKeyPair(
       base::Bind(&SaveKeyPair, &public_key2, &private_key2));
 
   std::string symmetric_key1, symmetric_key2;
   delegate_.DeriveKey(private_key1, public_key2,
                       base::Bind(&SaveString, &symmetric_key1));
   delegate_.DeriveKey(private_key2, public_key1,
                       base::Bind(&SaveString, &symmetric_key2));
 
   EXPECT_EQ(symmetric_key1, symmetric_key2);
 }
 
-TEST_F(ProximityAuthFakeSecureMessageDelegateTest,
+TEST_F(CryptAuthFakeSecureMessageDelegateTest,
        CreateAndUnwrapWithSymmetricKey) {
   // Create SecureMessage using symmetric key.
   SecureMessageDelegate::CreateOptions create_options =
       GetCreateOptions(securemessage::AES_256_CBC, securemessage::HMAC_SHA256);
   std::string serialized_message;
   delegate_.CreateSecureMessage(kPayload, kSymmetricKey, create_options,
                                 base::Bind(&SaveString, &serialized_message));
 
   CheckSerializedSecureMessage(serialized_message, create_options);
 
   // Unwrap SecureMessage using symmetric key.
   SecureMessageDelegate::UnwrapOptions unwrap_options =
       GetUnwrapOptions(securemessage::AES_256_CBC, securemessage::HMAC_SHA256);
   std::string payload;
   securemessage::Header header;
   delegate_.UnwrapSecureMessage(
       serialized_message, kSymmetricKey, unwrap_options,
       base::Bind(&SaveUnwrapResults, &payload, &header));
 
   EXPECT_EQ(kPayload, payload);
 }
 
-TEST_F(ProximityAuthFakeSecureMessageDelegateTest,
+TEST_F(CryptAuthFakeSecureMessageDelegateTest,
        CreateAndUnwrapWithAsymmetricKey) {
   delegate_.set_next_public_key(kTestPublicKey);
   std::string public_key, private_key;
   delegate_.GenerateKeyPair(
       base::Bind(&SaveKeyPair, &public_key, &private_key));
 
   // Create SecureMessage using asymmetric key.
   SecureMessageDelegate::CreateOptions create_options =
       GetCreateOptions(securemessage::NONE, securemessage::ECDSA_P256_SHA256);
   std::string serialized_message;
   delegate_.CreateSecureMessage(kPayload, private_key, create_options,
                                 base::Bind(&SaveString, &serialized_message));
 
   CheckSerializedSecureMessage(serialized_message, create_options);
 
   // Unwrap SecureMessage using symmetric key.
   SecureMessageDelegate::UnwrapOptions unwrap_options =
       GetUnwrapOptions(securemessage::NONE, securemessage::ECDSA_P256_SHA256);
   std::string payload;
   securemessage::Header header;
   delegate_.UnwrapSecureMessage(
       serialized_message, public_key, unwrap_options,
       base::Bind(&SaveUnwrapResults, &payload, &header));
 
   EXPECT_EQ(kPayload, payload);
 }
 
-TEST_F(ProximityAuthFakeSecureMessageDelegateTest, GetPrivateKeyForPublicKey) {
+TEST_F(CryptAuthFakeSecureMessageDelegateTest, GetPrivateKeyForPublicKey) {
   delegate_.set_next_public_key(kTestPublicKey);
   std::string public_key, private_key;
   delegate_.GenerateKeyPair(
       base::Bind(&SaveKeyPair, &public_key, &private_key));
   EXPECT_EQ(kTestPublicKey, public_key);
   EXPECT_EQ(private_key, delegate_.GetPrivateKeyForPublicKey(kTestPublicKey));
 }
 
 }  // proximity_auth