Minor Coverity nit: Unit test leaking data if failure occurs....

base/values_unittest.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2009 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 <limits>
 
 #include "base/values.h"
 #include "base/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class ValuesTest: public testing::Test {
@@ skipping 130 matching lines @@
   ASSERT_EQ(std::wstring(L"narrow"), wide);
   ASSERT_TRUE(wide_value->GetAsString(&narrow));
   ASSERT_TRUE(wide_value->GetAsString(&wide));
   ASSERT_EQ(std::string("wide"), narrow);
   ASSERT_EQ(std::wstring(L"wide"), wide);
 }
 
 // This is a Value object that allows us to tell if it's been
 // properly deleted by modifying the value of external flag on destruction.
 class DeletionTestValue : public Value {
-public:
+ public:
   DeletionTestValue(bool* deletion_flag) : Value(TYPE_NULL) {
     Init(deletion_flag);  // Separate function so that we can use ASSERT_*
   }
 
   void Init(bool* deletion_flag) {
     ASSERT_TRUE(deletion_flag);
     deletion_flag_ = deletion_flag;
     *deletion_flag_ = false;
   }
 
   ~DeletionTestValue() {
     *deletion_flag_ = true;
   }
 
-private:
+ private:
   bool* deletion_flag_;
 };
 
 TEST(ValuesTest, ListDeletion) {
   bool deletion_flag = true;
 
   {
     ListValue list;
     list.Append(new DeletionTestValue(&deletion_flag));
     EXPECT_FALSE(deletion_flag);
@@ skipping 127 matching lines @@
   BinaryValue* original_binary = Value::CreateBinaryValue(original_buffer, 42);
   original_dict.Set(L"binary", original_binary);
 
   ListValue* original_list = new ListValue();
   Value* original_list_element_0 = Value::CreateIntegerValue(0);
   original_list->Append(original_list_element_0);
   Value* original_list_element_1 = Value::CreateIntegerValue(1);
   original_list->Append(original_list_element_1);
   original_dict.Set(L"list", original_list);
 
-  DictionaryValue* copy_dict =
-    static_cast<DictionaryValue*>(original_dict.DeepCopy());
-  ASSERT_TRUE(copy_dict);
-  ASSERT_NE(copy_dict, &original_dict);
+  scoped_ptr<DictionaryValue> copy_dict(
+      static_cast<DictionaryValue*>(original_dict.DeepCopy()));
+  ASSERT_TRUE(copy_dict.get());
+  ASSERT_NE(copy_dict.get(), &original_dict);
 
   Value* copy_null = NULL;
   ASSERT_TRUE(copy_dict->Get(L"null", &copy_null));
   ASSERT_TRUE(copy_null);
   ASSERT_NE(copy_null, original_null);
   ASSERT_TRUE(copy_null->IsType(Value::TYPE_NULL));
 
   Value* copy_bool = NULL;
   ASSERT_TRUE(copy_dict->Get(L"bool", &copy_bool));
   ASSERT_TRUE(copy_bool);
@@ skipping 72 matching lines @@
   ASSERT_TRUE(copy_list_element_0->GetAsInteger(&copy_list_element_0_value));
   ASSERT_EQ(0, copy_list_element_0_value);
 
   Value* copy_list_element_1;
   ASSERT_TRUE(copy_list->Get(1, &copy_list_element_1));
   ASSERT_TRUE(copy_list_element_1);
   ASSERT_NE(copy_list_element_1, original_list_element_1);
   int copy_list_element_1_value;
   ASSERT_TRUE(copy_list_element_1->GetAsInteger(&copy_list_element_1_value));
   ASSERT_EQ(1, copy_list_element_1_value);
-
-  delete copy_dict;
 }
 
 TEST(ValuesTest, Equals) {
   Value* null1 = Value::CreateNullValue();
   Value* null2 = Value::CreateNullValue();
   EXPECT_NE(null1, null2);
   EXPECT_TRUE(null1->Equals(null2));
 
   Value* boolean = Value::CreateBooleanValue(false);
   EXPECT_FALSE(null1->Equals(boolean));
@@ skipping 18 matching lines @@
   dv.Set(L"f", list);
 
   EXPECT_FALSE(dv.Equals(copy));
   copy->Set(L"f", list->DeepCopy());
   EXPECT_TRUE(dv.Equals(copy));
 
   list->Append(Value::CreateBooleanValue(true));
   EXPECT_FALSE(dv.Equals(copy));
   delete copy;
 }