Add std::unique_ptr conversions to scoped_ptr.

base/memory/scoped_ptr_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 "base/memory/scoped_ptr.h"
 
 #include <stddef.h>
 
+#include <memory>
 #include <sstream>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // Used to test depth subtyping.
@@ skipping 813 matching lines @@
   EXPECT_FALSE(p < nullptr);
   EXPECT_TRUE(nullptr < p);
   EXPECT_FALSE(pnull < nullptr);
   EXPECT_FALSE(nullptr < pnull);
 
   EXPECT_FALSE(p <= nullptr);
   EXPECT_TRUE(nullptr <= p);
   EXPECT_TRUE(pnull <= nullptr);
   EXPECT_TRUE(nullptr <= pnull);
 }
+
+TEST(ScopedPtrTest, UniquePtrToScopedPtr) {
+  {
+    std::unique_ptr<int> u(new int(8));
+    scoped_ptr<int> s(std::move(u));
+    EXPECT_EQ(8, *s);
+  }
+
+  {
+    std::unique_ptr<int> u(new int(8));
+    scoped_ptr<int> s;
+    s = std::move(u);
+    EXPECT_EQ(8, *s);
+  }
+}
+
+TEST(ScopedPtrTest, UniquePtrToScopedPtrWithCustomDeleter) {
+  double dummy, dummy2;
+  int deletes = 0;
+
+  {
+    std::unique_ptr<double, CountingDeleterChild> u(
+        &dummy, CountingDeleterChild(&deletes));
+    scoped_ptr<double, CountingDeleter> s(std::move(u));
+    EXPECT_EQ(&dummy, s.get());
+  }
+  EXPECT_EQ(1, deletes);
+
+  int deletes2 = 0;
+  {
+    std::unique_ptr<double, CountingDeleterChild> u(
+        &dummy, CountingDeleterChild(&deletes));
+    scoped_ptr<double, CountingDeleter> s(&dummy2, CountingDeleter(&deletes2));
+    s = std::move(u);
+    EXPECT_EQ(&dummy, s.get());
+  }
+  EXPECT_EQ(2, deletes);
+  EXPECT_EQ(1, deletes2);
+}
+
+TEST(ScopedPtrTest, ScopedPtrToUniquePtr) {
+  {
+    scoped_ptr<int> s(new int(9));
+    std::unique_ptr<int> u(std::move(s));
+    EXPECT_EQ(9, *u);
+  }
+
+  {
+    scoped_ptr<int> s(new int(9));
+    std::unique_ptr<int> u;
+    u = std::move(s);
+    EXPECT_EQ(9, *u);
+  }
+}
+
+TEST(ScopedPtrTest, ScopedPtrToUniquePtrWithCustomDeleter) {
+  double dummy, dummy2;
+  int deletes = 0;
+
+  {
+    scoped_ptr<double, CountingDeleterChild> s(&dummy,
+                                               CountingDeleterChild(&deletes));
+    std::unique_ptr<double, CountingDeleter> u(std::move(s));
+    EXPECT_EQ(&dummy, u.get());
+  }
+  EXPECT_EQ(1, deletes);
+
+  int deletes2 = 0;
+  {
+    scoped_ptr<double, CountingDeleterChild> s(&dummy,
+                                               CountingDeleterChild(&deletes));
+    std::unique_ptr<double, CountingDeleter> u(&dummy2,
+                                               CountingDeleter(&deletes2));
+    u = std::move(s);
+    EXPECT_EQ(&dummy, u.get());
+  }
+  EXPECT_EQ(2, deletes);
+  EXPECT_EQ(1, deletes2);
+}