Clang format slam.

net/android/keystore_unittest.cc

 // Copyright (c) 2013 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 <openssl/bn.h>
 #include <openssl/dsa.h>
 #include <openssl/ecdsa.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/pem.h>
@@ skipping 44 matching lines @@
 namespace android {
 
 namespace {
 
 typedef crypto::ScopedOpenSSL<EVP_PKEY, EVP_PKEY_free> ScopedEVP_PKEY;
 typedef crypto::ScopedOpenSSL<RSA, RSA_free> ScopedRSA;
 typedef crypto::ScopedOpenSSL<DSA, DSA_free> ScopedDSA;
 typedef crypto::ScopedOpenSSL<EC_KEY, EC_KEY_free> ScopedEC_KEY;
 typedef crypto::ScopedOpenSSL<BIGNUM, BN_free> ScopedBIGNUM;
 
-typedef crypto::ScopedOpenSSL<
-    PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_free>
-        ScopedPKCS8_PRIV_KEY_INFO;
+typedef crypto::ScopedOpenSSL<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_free>
+    ScopedPKCS8_PRIV_KEY_INFO;
 
 typedef base::android::ScopedJavaLocalRef<jobject> ScopedJava;
 
 JNIEnv* InitEnv() {
   JNIEnv* env = base::android::AttachCurrentThread();
   static bool inited = false;
   if (!inited) {
     RegisterNativesImpl(env);
     inited = true;
   }
@@ skipping 40 matching lines @@
   base::FilePath certs_dir = GetTestCertsDirectory();
   base::FilePath file_path = certs_dir.AppendASCII(filename);
   ScopedStdioHandle handle(base::OpenFile(file_path, "rb"));
   if (!handle.get()) {
     LOG(ERROR) << "Could not open private key file: " << filename;
     return NULL;
   }
   // Assume it is PEM_encoded. Load it as an EVP_PKEY.
   EVP_PKEY* pkey = PEM_read_PrivateKey(handle.get(), NULL, NULL, NULL);
   if (!pkey) {
-    LOG(ERROR) << "Could not load public key file: " << filename
-               << ", " << GetOpenSSLErrorString();
+    LOG(ERROR) << "Could not load public key file: " << filename << ", "
+               << GetOpenSSLErrorString();
     return NULL;
   }
   return pkey;
 }
 
 // Convert a private key into its PKCS#8 encoded representation.
 // |pkey| is the EVP_PKEY handle for the private key.
 // |pkcs8| will receive the PKCS#8 bytes.
 // Returns true on success, false otherwise.
-bool GetPrivateKeyPkcs8Bytes(const ScopedEVP_PKEY& pkey,
-                             std::string* pkcs8) {
+bool GetPrivateKeyPkcs8Bytes(const ScopedEVP_PKEY& pkey, std::string* pkcs8) {
   // Convert to PKCS#8 object.
   ScopedPKCS8_PRIV_KEY_INFO p8_info(EVP_PKEY2PKCS8(pkey.get()));
   if (!p8_info.get()) {
     LOG(ERROR) << "Can't get PKCS#8 private key from EVP_PKEY: "
                << GetOpenSSLErrorString();
     return false;
   }
 
   // Then convert it
   int len = i2d_PKCS8_PRIV_KEY_INFO(p8_info.get(), NULL);
   unsigned char* p = OpenSSLWriteInto(pkcs8, static_cast<size_t>(len));
   i2d_PKCS8_PRIV_KEY_INFO(p8_info.get(), &p);
   return true;
 }
 
-bool ImportPrivateKeyFileAsPkcs8(const char* filename,
-                                 std::string* pkcs8) {
+bool ImportPrivateKeyFileAsPkcs8(const char* filename, std::string* pkcs8) {
   ScopedEVP_PKEY pkey(ImportPrivateKeyFile(filename));
   if (!pkey.get())
     return false;
   return GetPrivateKeyPkcs8Bytes(pkey, pkcs8);
 }
 
 // Same as ImportPrivateKey, but for public ones.
 EVP_PKEY* ImportPublicKeyFile(const char* filename) {
   // Load file as PEM data.
   base::FilePath certs_dir = GetTestCertsDirectory();
   base::FilePath file_path = certs_dir.AppendASCII(filename);
   ScopedStdioHandle handle(base::OpenFile(file_path, "rb"));
   if (!handle.get()) {
     LOG(ERROR) << "Could not open public key file: " << filename;
     return NULL;
   }
   EVP_PKEY* pkey = PEM_read_PUBKEY(handle.get(), NULL, NULL, NULL);
   if (!pkey) {
-    LOG(ERROR) << "Could not load public key file: " << filename
-               << ", " << GetOpenSSLErrorString();
+    LOG(ERROR) << "Could not load public key file: " << filename << ", "
+               << GetOpenSSLErrorString();
     return NULL;
   }
   return pkey;
 }
 
 // Retrieve a JNI local ref from encoded PKCS#8 data.
 ScopedJava GetPKCS8PrivateKeyJava(PrivateKeyType key_type,
                                   const std::string& pkcs8_key) {
   JNIEnv* env = InitEnv();
   base::android::ScopedJavaLocalRef<jbyteArray> bytes(
       base::android::ToJavaByteArray(
           env,
           reinterpret_cast<const uint8*>(pkcs8_key.data()),
           pkcs8_key.size()));
 
-  ScopedJava key(
-      Java_AndroidKeyStoreTestUtil_createPrivateKeyFromPKCS8(
-          env, key_type, bytes.obj()));
+  ScopedJava key(Java_AndroidKeyStoreTestUtil_createPrivateKeyFromPKCS8(
+      env, key_type, bytes.obj()));
 
   return key;
 }
 
 const char kTestRsaKeyFile[] = "android-test-key-rsa.pem";
 
 // The RSA test hash must be 36 bytes exactly.
 const char kTestRsaHash[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
 // Retrieve a JNI local ref for our test RSA key.
@@ skipping 24 matching lines @@
 // signature bits directly. However, one can use the public key
 // to do the check.
 bool VerifyTestDSASignature(const base::StringPiece& message,
                             const base::StringPiece& signature) {
   ScopedEVP_PKEY pkey(ImportPublicKeyFile(kTestDsaPublicKeyFile));
   if (!pkey.get())
     return false;
 
   ScopedDSA pub_key(EVP_PKEY_get1_DSA(pkey.get()));
   if (!pub_key.get()) {
-    LOG(ERROR) << "Could not get DSA public key: "
-               << GetOpenSSLErrorString();
+    LOG(ERROR) << "Could not get DSA public key: " << GetOpenSSLErrorString();
     return false;
   }
 
   const unsigned char* digest =
       reinterpret_cast<const unsigned char*>(message.data());
   int digest_len = static_cast<int>(message.size());
   const unsigned char* sigbuf =
       reinterpret_cast<const unsigned char*>(signature.data());
   int siglen = static_cast<int>(signature.size());
 
-  int ret = DSA_verify(
-      0, digest, digest_len, sigbuf, siglen, pub_key.get());
+  int ret = DSA_verify(0, digest, digest_len, sigbuf, siglen, pub_key.get());
   if (ret != 1) {
     LOG(ERROR) << "DSA_verify() failed: " << GetOpenSSLErrorString();
     return false;
   }
   return true;
 }
 
 const char kTestEcdsaKeyFile[] = "android-test-key-ecdsa.pem";
 const char kTestEcdsaPublicKeyFile[] = "android-test-key-ecdsa-public.pem";
 
@@ skipping 13 matching lines @@
 // random elements in the signature, it is not possible to compare
 // signature bits directly. However, one can use the public key
 // to do the check.
 bool VerifyTestECDSASignature(const base::StringPiece& message,
                               const base::StringPiece& signature) {
   ScopedEVP_PKEY pkey(ImportPublicKeyFile(kTestEcdsaPublicKeyFile));
   if (!pkey.get())
     return false;
   ScopedEC_KEY pub_key(EVP_PKEY_get1_EC_KEY(pkey.get()));
   if (!pub_key.get()) {
-    LOG(ERROR) << "Could not get ECDSA public key: "
-               << GetOpenSSLErrorString();
+    LOG(ERROR) << "Could not get ECDSA public key: " << GetOpenSSLErrorString();
     return false;
   }
 
   const unsigned char* digest =
       reinterpret_cast<const unsigned char*>(message.data());
   int digest_len = static_cast<int>(message.size());
   const unsigned char* sigbuf =
       reinterpret_cast<const unsigned char*>(signature.data());
   int siglen = static_cast<int>(signature.size());
 
-  int ret = ECDSA_verify(
-      0, digest, digest_len, sigbuf, siglen, pub_key.get());
+  int ret = ECDSA_verify(0, digest, digest_len, sigbuf, siglen, pub_key.get());
   if (ret != 1) {
     LOG(ERROR) << "ECDSA_verify() failed: " << GetOpenSSLErrorString();
     return false;
   }
   return true;
 }
 
 // Sign a message with OpenSSL, return the result as a string.
 // |message| is the message to be signed.
 // |openssl_key| is an OpenSSL EVP_PKEY to use.
 // |result| receives the result.
 // Returns true on success, false otherwise.
 bool SignWithOpenSSL(const base::StringPiece& message,
                      EVP_PKEY* openssl_key,
                      std::string* result) {
   const unsigned char* digest =
       reinterpret_cast<const unsigned char*>(message.data());
   unsigned int digest_len = static_cast<unsigned int>(message.size());
   std::string signature;
   size_t signature_size;
   size_t max_signature_size;
   int key_type = EVP_PKEY_id(openssl_key);
   switch (key_type) {
-    case EVP_PKEY_RSA:
-    {
+    case EVP_PKEY_RSA: {
       ScopedRSA rsa(EVP_PKEY_get1_RSA(openssl_key));
       if (!rsa.get()) {
         LOG(ERROR) << "Could not get RSA from EVP_PKEY: "
                    << GetOpenSSLErrorString();
         return false;
       }
       // With RSA, the signature will always be RSA_size() bytes.
       max_signature_size = static_cast<size_t>(RSA_size(rsa.get()));
-      unsigned char* p = OpenSSLWriteInto(&signature,
-                                          max_signature_size);
+      unsigned char* p = OpenSSLWriteInto(&signature, max_signature_size);
       unsigned int p_len = 0;
-      int ret = RSA_sign(
-          NID_md5_sha1, digest, digest_len, p, &p_len, rsa.get());
+      int ret =
+          RSA_sign(NID_md5_sha1, digest, digest_len, p, &p_len, rsa.get());
       if (ret != 1) {
         LOG(ERROR) << "RSA_sign() failed: " << GetOpenSSLErrorString();
         return false;
       }
       signature_size = static_cast<size_t>(p_len);
       break;
     }
-    case EVP_PKEY_DSA:
-    {
+    case EVP_PKEY_DSA: {
       ScopedDSA dsa(EVP_PKEY_get1_DSA(openssl_key));
       if (!dsa.get()) {
         LOG(ERROR) << "Could not get DSA from EVP_PKEY: "
                    << GetOpenSSLErrorString();
         return false;
       }
       // Note, the actual signature can be smaller than DSA_size()
       max_signature_size = static_cast<size_t>(DSA_size(dsa.get()));
-      unsigned char* p = OpenSSLWriteInto(&signature,
-                                          max_signature_size);
+      unsigned char* p = OpenSSLWriteInto(&signature, max_signature_size);
       unsigned int p_len = 0;
       // Note: first parameter is ignored by function.
       int ret = DSA_sign(0, digest, digest_len, p, &p_len, dsa.get());
       if (ret != 1) {
         LOG(ERROR) << "DSA_sign() failed: " << GetOpenSSLErrorString();
         return false;
       }
       signature_size = static_cast<size_t>(p_len);
       break;
     }
-    case EVP_PKEY_EC:
-    {
+    case EVP_PKEY_EC: {
       ScopedEC_KEY ecdsa(EVP_PKEY_get1_EC_KEY(openssl_key));
       if (!ecdsa.get()) {
         LOG(ERROR) << "Could not get EC_KEY from EVP_PKEY: "
                    << GetOpenSSLErrorString();
         return false;
       }
       // Note, the actual signature can be smaller than ECDSA_size()
       max_signature_size = ECDSA_size(ecdsa.get());
-      unsigned char* p = OpenSSLWriteInto(&signature,
-                                          max_signature_size);
+      unsigned char* p = OpenSSLWriteInto(&signature, max_signature_size);
       unsigned int p_len = 0;
       // Note: first parameter is ignored by function.
-      int ret = ECDSA_sign(
-          0, digest, digest_len, p, &p_len, ecdsa.get());
+      int ret = ECDSA_sign(0, digest, digest_len, p, &p_len, ecdsa.get());
       if (ret != 1) {
         LOG(ERROR) << "ECDSA_sign() fialed: " << GetOpenSSLErrorString();
         return false;
       }
       signature_size = static_cast<size_t>(p_len);
       break;
     }
     default:
       LOG(WARNING) << "Invalid OpenSSL key type: " << key_type;
       return false;
   }
 
   if (signature_size == 0) {
     LOG(ERROR) << "Signature is empty!";
     return false;
   }
   if (signature_size > max_signature_size) {
     LOG(ERROR) << "Signature size mismatch, actual " << signature_size
-                << ", expected <= " << max_signature_size;
+               << ", expected <= " << max_signature_size;
     return false;
   }
   signature.resize(signature_size);
   result->swap(signature);
   return true;
 }
 
 // Check that a generated signature for a given message matches
 // OpenSSL output byte-by-byte.
 // |message| is the input message.
 // |signature| is the generated signature for the message.
 // |openssl_key| is a raw EVP_PKEY for the same private key than the
 // one which was used to generate the signature.
 // Returns true on success, false otherwise.
 bool CompareSignatureWithOpenSSL(const base::StringPiece& message,
                                  const base::StringPiece& signature,
                                  EVP_PKEY* openssl_key) {
   std::string openssl_signature;
   SignWithOpenSSL(message, openssl_key, &openssl_signature);
 
   if (signature.size() != openssl_signature.size()) {
-    LOG(ERROR) << "Signature size mismatch, actual "
-               << signature.size() << ", expected "
-               << openssl_signature.size();
+    LOG(ERROR) << "Signature size mismatch, actual " << signature.size()
+               << ", expected " << openssl_signature.size();
     return false;
   }
   for (size_t n = 0; n < signature.size(); ++n) {
     if (openssl_signature[n] != signature[n]) {
-      LOG(ERROR) << "Signature byte mismatch at index " << n
-                 << "actual " << signature[n] << ", expected "
-                 << openssl_signature[n];
-      LOG(ERROR) << "Actual signature  : "
-                 << base::HexEncode(signature.data(), signature.size());
-      LOG(ERROR) << "Expected signature: "
-                 << base::HexEncode(openssl_signature.data(),
-                                    openssl_signature.size());
+      LOG(ERROR) << "Signature byte mismatch at index " << n << "actual "
+                 << signature[n] << ", expected " << openssl_signature[n];
+      LOG(ERROR) << "Actual signature  : " << base::HexEncode(signature.data(),
+                                                              signature.size());
+      LOG(ERROR) << "Expected signature: " << base::HexEncode(
+                                                  openssl_signature.data(),
+                                                  openssl_signature.size());
       return false;
     }
   }
   return true;
 }
 
 // Sign a message with our platform API.
 //
 // |android_key| is a JNI reference to the platform PrivateKey object.
 // |openssl_key| is a pointer to an OpenSSL key object for the exact
 // same key content.
 // |message| is a message.
 // |result| will receive the result.
 void DoKeySigning(jobject android_key,
                   EVP_PKEY* openssl_key,
                   const base::StringPiece& message,
                   std::string* result) {
   // First, get the platform signature.
   std::vector<uint8> android_signature;
   ASSERT_TRUE(
-      RawSignDigestWithPrivateKey(android_key,
-                                  message,
-                                  &android_signature));
+      RawSignDigestWithPrivateKey(android_key, message, &android_signature));
 
-  result->assign(
-      reinterpret_cast<const char*>(&android_signature[0]),
-      android_signature.size());
+  result->assign(reinterpret_cast<const char*>(&android_signature[0]),
+                 android_signature.size());
 }
 
 // Sign a message with our OpenSSL EVP_PKEY wrapper around platform
 // APIS.
 //
 // |android_key| is a JNI reference to the platform PrivateKey object.
 // |openssl_key| is a pointer to an OpenSSL key object for the exact
 // same key content.
 // |message| is a message.
 // |result| will receive the result.
 void DoKeySigningWithWrapper(EVP_PKEY* wrapper_key,
                              EVP_PKEY* openssl_key,
                              const base::StringPiece& message,
                              std::string* result) {
   // First, get the platform signature.
   std::string wrapper_signature;
   SignWithOpenSSL(message, wrapper_key, &wrapper_signature);
   ASSERT_NE(0U, wrapper_signature.size());
 
-  result->assign(
-      reinterpret_cast<const char*>(&wrapper_signature[0]),
-      wrapper_signature.size());
+  result->assign(reinterpret_cast<const char*>(&wrapper_signature[0]),
+                 wrapper_signature.size());
 }
 
 }  // namespace
 
-TEST(AndroidKeyStore,GetRSAKeyModulus) {
+TEST(AndroidKeyStore, GetRSAKeyModulus) {
   crypto::OpenSSLErrStackTracer err_trace(FROM_HERE);
   InitEnv();
 
   // Load the test RSA key.
   ScopedEVP_PKEY pkey(ImportPrivateKeyFile(kTestRsaKeyFile));
   ASSERT_TRUE(pkey.get());
 
   // Convert it to encoded PKCS#8 bytes.
   std::string pkcs8_data;
   ASSERT_TRUE(GetPrivateKeyPkcs8Bytes(pkey, &pkcs8_data));
 
   // Create platform PrivateKey object from it.
-  ScopedJava key_java = GetPKCS8PrivateKeyJava(PRIVATE_KEY_TYPE_RSA,
-                                                pkcs8_data);
+  ScopedJava key_java =
+      GetPKCS8PrivateKeyJava(PRIVATE_KEY_TYPE_RSA, pkcs8_data);
   ASSERT_FALSE(key_java.is_null());
 
   // Retrieve the corresponding modulus through JNI
   std::vector<uint8> modulus_java;
   ASSERT_TRUE(GetRSAKeyModulus(key_java.obj(), &modulus_java));
 
   // Create an OpenSSL BIGNUM from it.
   ScopedBIGNUM bn(
-      BN_bin2bn(
-          reinterpret_cast<const unsigned char*>(&modulus_java[0]),
-          static_cast<int>(modulus_java.size()),
-          NULL));
+      BN_bin2bn(reinterpret_cast<const unsigned char*>(&modulus_java[0]),
+                static_cast<int>(modulus_java.size()),
+                NULL));
   ASSERT_TRUE(bn.get());
 
   // Compare it to the one in the RSA key, they must be identical.
   ScopedRSA rsa(EVP_PKEY_get1_RSA(pkey.get()));
   ASSERT_TRUE(rsa.get()) << GetOpenSSLErrorString();
 
   ASSERT_EQ(0, BN_cmp(bn.get(), rsa.get()->n));
 }
 
-TEST(AndroidKeyStore,GetDSAKeyParamQ) {
+TEST(AndroidKeyStore, GetDSAKeyParamQ) {
   crypto::OpenSSLErrStackTracer err_trace(FROM_HERE);
   InitEnv();
 
   // Load the test DSA key.
   ScopedEVP_PKEY pkey(ImportPrivateKeyFile(kTestDsaKeyFile));
   ASSERT_TRUE(pkey.get());
 
   // Convert it to encoded PKCS#8 bytes.
   std::string pkcs8_data;
   ASSERT_TRUE(GetPrivateKeyPkcs8Bytes(pkey, &pkcs8_data));
 
   // Create platform PrivateKey object from it.
-  ScopedJava key_java = GetPKCS8PrivateKeyJava(PRIVATE_KEY_TYPE_DSA,
-                                                pkcs8_data);
+  ScopedJava key_java =
+      GetPKCS8PrivateKeyJava(PRIVATE_KEY_TYPE_DSA, pkcs8_data);
   ASSERT_FALSE(key_java.is_null());
 
   // Retrieve the corresponding Q parameter through JNI
   std::vector<uint8> q_java;
   ASSERT_TRUE(GetDSAKeyParamQ(key_java.obj(), &q_java));
 
   // Create an OpenSSL BIGNUM from it.
-  ScopedBIGNUM bn(
-      BN_bin2bn(
-          reinterpret_cast<const unsigned char*>(&q_java[0]),
-          static_cast<int>(q_java.size()),
-          NULL));
+  ScopedBIGNUM bn(BN_bin2bn(reinterpret_cast<const unsigned char*>(&q_java[0]),
+                            static_cast<int>(q_java.size()),
+                            NULL));
   ASSERT_TRUE(bn.get());
 
   // Compare it to the one in the RSA key, they must be identical.
   ScopedDSA dsa(EVP_PKEY_get1_DSA(pkey.get()));
   ASSERT_TRUE(dsa.get()) << GetOpenSSLErrorString();
 
   ASSERT_EQ(0, BN_cmp(bn.get(), dsa.get()->q));
 }
 
-TEST(AndroidKeyStore,GetPrivateKeyTypeRSA) {
+TEST(AndroidKeyStore, GetPrivateKeyTypeRSA) {
   crypto::OpenSSLErrStackTracer err_trace(FROM_HERE);
 
   ScopedJava rsa_key = GetRSATestKeyJava();
   ASSERT_FALSE(rsa_key.is_null());
-  EXPECT_EQ(PRIVATE_KEY_TYPE_RSA,
-            GetPrivateKeyType(rsa_key.obj()));
+  EXPECT_EQ(PRIVATE_KEY_TYPE_RSA, GetPrivateKeyType(rsa_key.obj()));
 }
 
-TEST(AndroidKeyStore,SignWithPrivateKeyRSA) {
+TEST(AndroidKeyStore, SignWithPrivateKeyRSA) {
   ScopedJava rsa_key = GetRSATestKeyJava();
   ASSERT_FALSE(rsa_key.is_null());
 
   if (IsOnAndroidOlderThan_4_2()) {
     LOG(INFO) << "This test can't run on Android < 4.2";
     return;
   }
 
   ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestRsaKeyFile));
   ASSERT_TRUE(openssl_key.get());
 
   std::string message = kTestRsaHash;
   ASSERT_EQ(36U, message.size());
 
   std::string signature;
   DoKeySigning(rsa_key.obj(), openssl_key.get(), message, &signature);
   ASSERT_TRUE(
       CompareSignatureWithOpenSSL(message, signature, openssl_key.get()));
   // All good.
 }
 
-TEST(AndroidKeyStore,SignWithWrapperKeyRSA) {
+TEST(AndroidKeyStore, SignWithWrapperKeyRSA) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   ScopedJava rsa_key = GetRSATestKeyJava();
   ASSERT_FALSE(rsa_key.is_null());
 
   ScopedEVP_PKEY wrapper_key(GetOpenSSLPrivateKeyWrapper(rsa_key.obj()));
   ASSERT_TRUE(wrapper_key.get() != NULL);
 
   ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestRsaKeyFile));
   ASSERT_TRUE(openssl_key.get());
 
   // Check that RSA_size() works properly on the wrapper key.
-  EXPECT_EQ(EVP_PKEY_size(openssl_key.get()),
-            EVP_PKEY_size(wrapper_key.get()));
+  EXPECT_EQ(EVP_PKEY_size(openssl_key.get()), EVP_PKEY_size(wrapper_key.get()));
 
   // Message size must be 36 for RSA_sign(NID_md5_sha1,...) to return
   // without an error.
   std::string message = kTestRsaHash;
   ASSERT_EQ(36U, message.size());
 
   std::string signature;
-  DoKeySigningWithWrapper(wrapper_key.get(),
-                          openssl_key.get(),
-                          message,
-                          &signature);
+  DoKeySigningWithWrapper(
+      wrapper_key.get(), openssl_key.get(), message, &signature);
   ASSERT_TRUE(
       CompareSignatureWithOpenSSL(message, signature, openssl_key.get()));
 }
 
-TEST(AndroidKeyStore,GetPrivateKeyTypeDSA) {
+TEST(AndroidKeyStore, GetPrivateKeyTypeDSA) {
   crypto::OpenSSLErrStackTracer err_trace(FROM_HERE);
 
   ScopedJava dsa_key = GetDSATestKeyJava();
   ASSERT_FALSE(dsa_key.is_null());
-  EXPECT_EQ(PRIVATE_KEY_TYPE_DSA,
-            GetPrivateKeyType(dsa_key.obj()));
+  EXPECT_EQ(PRIVATE_KEY_TYPE_DSA, GetPrivateKeyType(dsa_key.obj()));
 }
 
-TEST(AndroidKeyStore,SignWithPrivateKeyDSA) {
+TEST(AndroidKeyStore, SignWithPrivateKeyDSA) {
   ScopedJava dsa_key = GetDSATestKeyJava();
   ASSERT_FALSE(dsa_key.is_null());
 
   ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestDsaKeyFile));
   ASSERT_TRUE(openssl_key.get());
 
   std::string message = kTestDsaHash;
   ASSERT_EQ(20U, message.size());
 
   std::string signature;
   DoKeySigning(dsa_key.obj(), openssl_key.get(), message, &signature);
   ASSERT_TRUE(VerifyTestDSASignature(message, signature));
 }
 
-TEST(AndroidKeyStore,SignWithWrapperKeyDSA) {
+TEST(AndroidKeyStore, SignWithWrapperKeyDSA) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   ScopedJava dsa_key = GetDSATestKeyJava();
   ASSERT_FALSE(dsa_key.is_null());
 
-  ScopedEVP_PKEY wrapper_key(
-      GetOpenSSLPrivateKeyWrapper(dsa_key.obj()));
+  ScopedEVP_PKEY wrapper_key(GetOpenSSLPrivateKeyWrapper(dsa_key.obj()));
   ASSERT_TRUE(wrapper_key.get());
 
   ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestDsaKeyFile));
   ASSERT_TRUE(openssl_key.get());
 
   // Check that DSA_size() works correctly on the wrapper.
-  EXPECT_EQ(EVP_PKEY_size(openssl_key.get()),
-            EVP_PKEY_size(wrapper_key.get()));
+  EXPECT_EQ(EVP_PKEY_size(openssl_key.get()), EVP_PKEY_size(wrapper_key.get()));
 
   std::string message = kTestDsaHash;
   std::string signature;
-  DoKeySigningWithWrapper(wrapper_key.get(),
-                          openssl_key.get(),
-                          message,
-                          &signature);
+  DoKeySigningWithWrapper(
+      wrapper_key.get(), openssl_key.get(), message, &signature);
   ASSERT_TRUE(VerifyTestDSASignature(message, signature));
 }
 
-TEST(AndroidKeyStore,GetPrivateKeyTypeECDSA) {
+TEST(AndroidKeyStore, GetPrivateKeyTypeECDSA) {
   crypto::OpenSSLErrStackTracer err_trace(FROM_HERE);
 
   ScopedJava ecdsa_key = GetECDSATestKeyJava();
   ASSERT_FALSE(ecdsa_key.is_null());
-  EXPECT_EQ(PRIVATE_KEY_TYPE_ECDSA,
-            GetPrivateKeyType(ecdsa_key.obj()));
+  EXPECT_EQ(PRIVATE_KEY_TYPE_ECDSA, GetPrivateKeyType(ecdsa_key.obj()));
 }
 
-TEST(AndroidKeyStore,SignWithPrivateKeyECDSA) {
+TEST(AndroidKeyStore, SignWithPrivateKeyECDSA) {
   ScopedJava ecdsa_key = GetECDSATestKeyJava();
   ASSERT_FALSE(ecdsa_key.is_null());
 
   ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestEcdsaKeyFile));
   ASSERT_TRUE(openssl_key.get());
 
   std::string message = kTestEcdsaHash;
   std::string signature;
   DoKeySigning(ecdsa_key.obj(), openssl_key.get(), message, &signature);
   ASSERT_TRUE(VerifyTestECDSASignature(message, signature));
 }
 
 TEST(AndroidKeyStore, SignWithWrapperKeyECDSA) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   ScopedJava ecdsa_key = GetECDSATestKeyJava();
   ASSERT_FALSE(ecdsa_key.is_null());
 
-  ScopedEVP_PKEY wrapper_key(
-      GetOpenSSLPrivateKeyWrapper(ecdsa_key.obj()));
+  ScopedEVP_PKEY wrapper_key(GetOpenSSLPrivateKeyWrapper(ecdsa_key.obj()));
   ASSERT_TRUE(wrapper_key.get());
 
   ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestEcdsaKeyFile));
   ASSERT_TRUE(openssl_key.get());
 
   // Check that ECDSA size works correctly on the wrapper.
-  EXPECT_EQ(EVP_PKEY_size(openssl_key.get()),
-            EVP_PKEY_size(wrapper_key.get()));
+  EXPECT_EQ(EVP_PKEY_size(openssl_key.get()), EVP_PKEY_size(wrapper_key.get()));
 
   std::string message = kTestEcdsaHash;
   std::string signature;
-  DoKeySigningWithWrapper(wrapper_key.get(),
-                          openssl_key.get(),
-                          message,
-                          &signature);
+  DoKeySigningWithWrapper(
+      wrapper_key.get(), openssl_key.get(), message, &signature);
   ASSERT_TRUE(VerifyTestECDSASignature(message, signature));
 }
 
 }  // namespace android
 }  // namespace net