Add tests for RSA private key import using JWK when p and q are swapped.

content/child/webcrypto/test/test_helpers.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 "content/child/webcrypto/test/test_helpers.h"
 
 #include <algorithm>
 
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 21 matching lines @@
 
 #include "crypto/nss_util.h"
 #include "crypto/scoped_nss_types.h"
 #endif
 
 namespace content {
 
 namespace webcrypto {
 
 void PrintTo(const Status& status, ::std::ostream* os) {
-  if (status.IsSuccess())
-    *os << "Success";
-  else
-    *os << "Error type: " << status.error_type()
-        << " Error details: " << status.error_details();
+  *os << StatusToString(status);
 }
 
 bool operator==(const Status& a, const Status& b) {
   if (a.IsSuccess() != b.IsSuccess())
     return false;
   if (a.IsSuccess())
     return true;
   return a.error_type() == b.error_type() &&
          a.error_details() == b.error_details();
 }
 
 bool operator!=(const Status& a, const Status& b) {
   return !(a == b);
 }
 
 void PrintTo(const CryptoData& data, ::std::ostream* os) {
   *os << "[" << base::HexEncode(data.bytes(), data.byte_length()) << "]";
 }
 
 bool operator==(const CryptoData& a, const CryptoData& b) {
   return a.byte_length() == b.byte_length() &&
          memcmp(a.bytes(), b.bytes(), a.byte_length()) == 0;
 }
 
 bool operator!=(const CryptoData& a, const CryptoData& b) {
   return !(a == b);
 }
 
+static std::string ErrorTypeToString(blink::WebCryptoErrorType type) {
+  switch (type) {
+    case blink::WebCryptoErrorTypeNotSupported:
+      return "NotSupported";
+    case blink::WebCryptoErrorTypeType:
+      return "TypeError";
+    case blink::WebCryptoErrorTypeData:
+      return "DataError";
+    case blink::WebCryptoErrorTypeSyntax:
+      return "SyntaxError";
+    case blink::WebCryptoErrorTypeOperation:
+      return "OperationError";
+    case blink::WebCryptoErrorTypeUnknown:
+      return "UnknownError";
+    case blink::WebCryptoErrorTypeInvalidState:
+      return "InvalidState";
+    case blink::WebCryptoErrorTypeInvalidAccess:
+      return "InvalidAccess";
+  }
+
+  return "?";
+}
+
+std::string StatusToString(const Status& status) {
+  if (status.IsSuccess())
+    return "Success";
+
+  std::string result = ErrorTypeToString(status.error_type());
+  if (!status.error_details().empty())
+    result += ": " + status.error_details();
+  return result;
+}
+
 bool SupportsAesGcm() {
   std::vector<uint8_t> key_raw(16, 0);
 
   blink::WebCryptoKey key;
   Status status = ImportKey(blink::WebCryptoKeyFormatRaw,
                             CryptoData(key_raw),
                             CreateAlgorithm(blink::WebCryptoAlgorithmIdAesGcm),
                             true,
                             blink::WebCryptoKeyUsageEncrypt,
                             &key);
@@ skipping 546 matching lines @@
 
   *public_key = result.public_key();
   *private_key = result.private_key();
 
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namesapce content