Update from https://crrev.com/307664

crypto/p224_spake_unittest.cc

 // Copyright (c) 2011 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 "crypto/p224_spake.h"
+
 #include <string>
-#include <crypto/p224_spake.h>
 
 #include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace crypto {
 
 namespace {
 
+std::string HexEncodeString(const std::string& binary_data) {
+  return base::HexEncode(binary_data.c_str(), binary_data.size());
+}
+
 bool RunExchange(P224EncryptedKeyExchange* client,
                  P224EncryptedKeyExchange* server,
                  bool is_password_same) {
   for (;;) {
     std::string client_message, server_message;
     client_message = client->GetMessage();
     server_message = server->GetMessage();
 
     P224EncryptedKeyExchange::Result client_result, server_result;
     client_result = client->ProcessMessage(server_message);
@@ skipping 39 matching lines @@
   P224EncryptedKeyExchange client(
       P224EncryptedKeyExchange::kPeerTypeClient,
       kPassword);
   P224EncryptedKeyExchange server(
       P224EncryptedKeyExchange::kPeerTypeServer,
       "wrongpassword");
 
   EXPECT_FALSE(RunExchange(&client, &server, false));
 }
 
+TEST(MutualAuth, ExpectedValues) {
+  P224EncryptedKeyExchange client(P224EncryptedKeyExchange::kPeerTypeClient,
+                                  kPassword);
+  client.SetXForTesting("Client x");
+  P224EncryptedKeyExchange server(P224EncryptedKeyExchange::kPeerTypeServer,
+                                  kPassword);
+  server.SetXForTesting("Server x");
+
+  std::string client_message = client.GetMessage();
+  EXPECT_EQ(
+      "3508EF7DECC8AB9F9C439FBB0154288BBECC0A82E8448F4CF29554EB"
+      "BE9D486686226255EAD1D077C635B1A41F46AC91D7F7F32CED9EC3E0",
+      HexEncodeString(client_message));
+
+  std::string server_message = server.GetMessage();
+  EXPECT_EQ(
+      "A3088C18B75D2C2B107105661AEC85424777475EB29F1DDFB8C14AFB"
+      "F1603D0DF38413A00F420ACF2059E7997C935F5A957A193D09A2B584",
+      HexEncodeString(server_message));
+
+  EXPECT_EQ(P224EncryptedKeyExchange::kResultPending,
+            client.ProcessMessage(server_message));
+  EXPECT_EQ(P224EncryptedKeyExchange::kResultPending,
+            server.ProcessMessage(client_message));
+
+  EXPECT_EQ(client.GetUnverifiedKey(), server.GetUnverifiedKey());
+  // Must stay the same. External implementations should be able to pair with.
+  EXPECT_EQ(
+      "CE7CCFC435CDA4F01EC8826788B1F8B82EF7D550A34696B371096E64"
+      "C487D4FE193F7D1A6FF6820BC7F807796BA3889E8F999BBDEFC32FFA",
+      HexEncodeString(server.GetUnverifiedKey()));
+
+  EXPECT_TRUE(RunExchange(&client, &server, true));
+  EXPECT_EQ(client.GetKey(), server.GetKey());
+}
+
 TEST(MutualAuth, Fuzz) {
   static const unsigned kIterations = 40;
 
   for (unsigned i = 0; i < kIterations; i++) {
     P224EncryptedKeyExchange client(
         P224EncryptedKeyExchange::kPeerTypeClient, kPassword);
     P224EncryptedKeyExchange server(
         P224EncryptedKeyExchange::kPeerTypeServer, kPassword);
 
     // We'll only be testing small values of i, but we don't want that to bias
@@ skipping 39 matching lines @@
 
       ASSERT_EQ(P224EncryptedKeyExchange::kResultPending,
                 client_result);
       ASSERT_EQ(P224EncryptedKeyExchange::kResultPending,
                 server_result);
     }
   }
 }
 
 }  // namespace crypto