Destroy all Singletons and LazyInstances between each test.

chromeos/network/onc/onc_certificate_importer_unittest.cc

 // Copyright (c) 2012 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 "chromeos/network/onc/onc_certificate_importer.h"
 
 #include <cert.h>
 #include <certdb.h>
 #include <keyhi.h>
 #include <pk11pub.h>
@@ skipping 137 matching lines @@
 
   crypto::ScopedTestNSSDB test_nssdb_;
 };
 
 TEST_F(ONCCertificateImporterTest, MultipleCertificates) {
   AddCertificatesFromFile("managed_toplevel2.onc",
                           CertificateImporter::IMPORT_OK);
   EXPECT_EQ(onc_certificates_->GetSize(), result_list_.size());
 }
 
-TEST_F(ONCCertificateImporterTest, MultipleCertificatesWithFailures) {
+// Doesn't work with singleton isolation <http://crbug.com/238654>.

[Paweł Hajdan Jr., 2013/05/08 16:32:25]

Please find a good owner for this bug, and let the owner sign off on this patch
*before* it is checked in.

I think you're hitting the same problems I hit before - and maybe that's indeed
the way to handle it for now (it's a huge improvement for stability of the
tests), but hey, we're really decreasing our test coverage in a pretty important
area.

[Robert Sesek, 2013/05/08 16:42:11]

Done. I think the net win outweighs the importance of any one test, though.

+TEST_F(ONCCertificateImporterTest, DISABLED_MultipleCertificatesWithFailures) {
   AddCertificatesFromFile("toplevel_partially_invalid.onc",
                           CertificateImporter::IMPORT_INCOMPLETE);
   EXPECT_EQ(2ul, onc_certificates_->GetSize());
   EXPECT_EQ(1ul, result_list_.size());
 }
 
-TEST_F(ONCCertificateImporterTest, AddClientCertificate) {
+// Doesn't work with singleton isolation <http://crbug.com/238654>.
+TEST_F(ONCCertificateImporterTest, DISABLED_AddClientCertificate) {
   std::string guid;
   AddCertificateFromFile("certificate-client.onc", net::USER_CERT, &guid);
   EXPECT_TRUE(web_trust_certificates_.empty());
 
   SECKEYPrivateKeyList* privkey_list =
       PK11_ListPrivKeysInSlot(slot_->os_module_handle(), NULL, NULL);
   EXPECT_TRUE(privkey_list);
   if (privkey_list) {
     SECKEYPrivateKeyListNode* node = PRIVKEY_LIST_HEAD(privkey_list);
     int count = 0;
@@ skipping 16 matching lines @@
     int count = 0;
     while (!PUBKEY_LIST_END(node, pubkey_list)) {
       count++;
       node = PUBKEY_LIST_NEXT(node);
     }
     EXPECT_EQ(1, count);
     SECKEY_DestroyPublicKeyList(pubkey_list);
   }
 }
 
-TEST_F(ONCCertificateImporterTest, AddServerCertificate) {
+// Doesn't work with singleton isolation <http://crbug.com/238654>.
+TEST_F(ONCCertificateImporterTest, DISABLED_AddServerCertificate) {
   std::string guid;
   AddCertificateFromFile("certificate-server.onc", net::SERVER_CERT, &guid);
 
   SECKEYPrivateKeyList* privkey_list =
       PK11_ListPrivKeysInSlot(slot_->os_module_handle(), NULL, NULL);
   EXPECT_FALSE(privkey_list);
 
   SECKEYPublicKeyList* pubkey_list =
       PK11_ListPublicKeysInSlot(slot_->os_module_handle(), NULL);
   EXPECT_FALSE(pubkey_list);
 
   ASSERT_EQ(1u, web_trust_certificates_.size());
   ASSERT_EQ(1u, result_list_.size());
   EXPECT_TRUE(CERT_CompareCerts(result_list_[0]->os_cert_handle(),
                                 web_trust_certificates_[0]->os_cert_handle()));
 }
 
-TEST_F(ONCCertificateImporterTest, AddWebAuthorityCertificate) {
+// Doesn't work with singleton isolation <http://crbug.com/238654>.
+TEST_F(ONCCertificateImporterTest, DISABLED_AddWebAuthorityCertificate) {
   std::string guid;
   AddCertificateFromFile("certificate-web-authority.onc", net::CA_CERT, &guid);
 
   SECKEYPrivateKeyList* privkey_list =
       PK11_ListPrivKeysInSlot(slot_->os_module_handle(), NULL, NULL);
   EXPECT_FALSE(privkey_list);
 
   SECKEYPublicKeyList* pubkey_list =
       PK11_ListPublicKeysInSlot(slot_->os_module_handle(), NULL);
   EXPECT_FALSE(pubkey_list);
 
   ASSERT_EQ(1u, web_trust_certificates_.size());
   ASSERT_EQ(1u, result_list_.size());
   EXPECT_TRUE(CERT_CompareCerts(result_list_[0]->os_cert_handle(),
                                 web_trust_certificates_[0]->os_cert_handle()));
 }
 
-TEST_F(ONCCertificateImporterTest, AddAuthorityCertificateWithoutWebTrust) {
+// Doesn't work with singleton isolation <http://crbug.com/238654>.
+TEST_F(ONCCertificateImporterTest,
+       DISABLED_AddAuthorityCertificateWithoutWebTrust) {
   std::string guid;
   AddCertificateFromFile("certificate-authority.onc", net::CA_CERT, &guid);
   EXPECT_TRUE(web_trust_certificates_.empty());
 
   SECKEYPrivateKeyList* privkey_list =
       PK11_ListPrivKeysInSlot(slot_->os_module_handle(), NULL, NULL);
   EXPECT_FALSE(privkey_list);
 
   SECKEYPublicKeyList* pubkey_list =
       PK11_ListPublicKeysInSlot(slot_->os_module_handle(), NULL);
@@ skipping 11 matching lines @@
   net::CertType cert_type;
   const char* original_file;
   const char* update_file;
 };
 
 class ONCCertificateImporterTestWithParam :
       public ONCCertificateImporterTest,
       public testing::WithParamInterface<CertParam> {
 };
 
-TEST_P(ONCCertificateImporterTestWithParam, UpdateCertificate) {
+// Doesn't work with singleton isolation <http://crbug.com/238654>.
+TEST_P(ONCCertificateImporterTestWithParam, DISABLED_UpdateCertificate) {
   // First we import a certificate.
   {
     SCOPED_TRACE("Import original certificate");
     std::string guid_original;
     AddCertificateFromFile(GetParam().original_file, GetParam().cert_type,
                            &guid_original);
   }
 
   // Now we import the same certificate with a different GUID. The cert should
   // be retrievable via the new GUID.
   {
     SCOPED_TRACE("Import updated certificate");
     std::string guid_updated;
     AddCertificateFromFile(GetParam().update_file, GetParam().cert_type,
                            &guid_updated);
   }
 }
 
-TEST_P(ONCCertificateImporterTestWithParam, ReimportCertificate) {
+// Doesn't work with singleton isolation <http://crbug.com/238654>.
+TEST_P(ONCCertificateImporterTestWithParam, DISABLED_ReimportCertificate) {
   // Verify that reimporting a client certificate works.
   for (int i = 0; i < 2; ++i) {
     SCOPED_TRACE("Import certificate, iteration " + base::IntToString(i));
 
     std::string guid_original;
     AddCertificateFromFile(GetParam().original_file, GetParam().cert_type,
                            &guid_original);
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
     ONCCertificateImporterTestWithParam,
     ONCCertificateImporterTestWithParam,
     ::testing::Values(
         CertParam(net::USER_CERT,
                   "certificate-client.onc",
                   "certificate-client-update.onc"),
         CertParam(net::SERVER_CERT,
                   "certificate-server.onc",
                   "certificate-server-update.onc"),
         CertParam(net::CA_CERT,
                   "certificate-web-authority.onc",
                   "certificate-web-authority-update.onc")));
 
 }  // namespace onc
 }  // namespace chromeos