base/scoped_generic_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <vector>
   6
   7 #include "base/scoped_generic.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace base {
  11
  12 namespace {
  13
  14 struct IntTraits {
  15   IntTraits(std::vector<int>* freed) : freed_ints(freed) {}
  16
  17   static int InvalidValue() {
  18     return -1;
  19   }
  20   void Free(int value) {
  21     freed_ints->push_back(value);
  22   }
  23
  24   std::vector<int>* freed_ints;
  25 };
  26
  27 typedef ScopedGeneric<int, IntTraits> ScopedInt;
  28
  29 }  // namespace
  30
  31 TEST(ScopedGenericTest, ScopedGeneric) {
  32   std::vector<int> values_freed;
  33   IntTraits traits(&values_freed);
  34
  35   // Invalid case, delete should not be called.
  36   {
  37     ScopedInt a(IntTraits::InvalidValue(), traits);
  38   }
  39   EXPECT_TRUE(values_freed.empty());
  40
  41   // Simple deleting case.
  42   static const int kFirst = 0;
  43   {
  44     ScopedInt a(kFirst, traits);
  45   }
  46   ASSERT_EQ(1u, values_freed.size());
  47   ASSERT_EQ(kFirst, values_freed[0]);
  48   values_freed.clear();
  49
  50   // Release should return the right value and leave the object empty.
  51   {
  52     ScopedInt a(kFirst, traits);
  53     EXPECT_EQ(kFirst, a.release());
  54
  55     ScopedInt b(IntTraits::InvalidValue(), traits);
  56     EXPECT_EQ(IntTraits::InvalidValue(), b.release());
  57   }
  58   ASSERT_TRUE(values_freed.empty());
  59
  60   // Reset should free the old value, then the new one should go away when
  61   // it goes out of scope.
  62   static const int kSecond = 1;
  63   {
  64     ScopedInt b(kFirst, traits);
  65     b.reset(kSecond);
  66     ASSERT_EQ(1u, values_freed.size());
  67     ASSERT_EQ(kFirst, values_freed[0]);
  68   }
  69   ASSERT_EQ(2u, values_freed.size());
  70   ASSERT_EQ(kSecond, values_freed[1]);
  71   values_freed.clear();
  72
  73   // Swap.
  74   {
  75     ScopedInt a(kFirst, traits);
  76     ScopedInt b(kSecond, traits);
  77     a.swap(b);
  78     EXPECT_TRUE(values_freed.empty());  // Nothing should be freed.
  79     EXPECT_EQ(kSecond, a.get());
  80     EXPECT_EQ(kFirst, b.get());
  81   }
  82   // Values should be deleted in the opposite order.
  83   ASSERT_EQ(2u, values_freed.size());
  84   EXPECT_EQ(kFirst, values_freed[0]);
  85   EXPECT_EQ(kSecond, values_freed[1]);
  86   values_freed.clear();
  87
  88   // Pass.
  89   {
  90     ScopedInt a(kFirst, traits);
  91     ScopedInt b(a.Pass());
  92     EXPECT_TRUE(values_freed.empty());  // Nothing should be freed.
  93     ASSERT_EQ(IntTraits::InvalidValue(), a.get());
  94     ASSERT_EQ(kFirst, b.get());
  95   }
  96   ASSERT_EQ(1u, values_freed.size());
  97   ASSERT_EQ(kFirst, values_freed[0]);
  98 }
  99
 100 TEST(ScopedGenericTest, Operators) {
 101   std::vector<int> values_freed;
 102   IntTraits traits(&values_freed);
 103
 104   static const int kFirst = 0;
 105   static const int kSecond = 1;
 106   {
 107     ScopedInt a(kFirst, traits);
 108     EXPECT_TRUE(a == kFirst);
 109     EXPECT_FALSE(a != kFirst);
 110     EXPECT_FALSE(a == kSecond);
 111     EXPECT_TRUE(a != kSecond);
 112
 113     EXPECT_TRUE(kFirst == a);
 114     EXPECT_FALSE(kFirst != a);
 115     EXPECT_FALSE(kSecond == a);
 116     EXPECT_TRUE(kSecond != a);
 117   }
 118
 119   // is_valid().
 120   {
 121     ScopedInt a(kFirst, traits);
 122     EXPECT_TRUE(a.is_valid());
 123     a.reset();
 124     EXPECT_FALSE(a.is_valid());
 125   }
 126 }
 127
 128 // Cheesy manual "no compile" test for manually validating changes.
 129 #if 0
 130 TEST(ScopedGenericTest, NoCompile) {
 131   // Assignment shouldn't work.
 132   /*{
 133     ScopedInt a(kFirst, traits);
 134     ScopedInt b(a);
 135   }*/
 136
 137   // Comparison shouldn't work.
 138   /*{
 139     ScopedInt a(kFirst, traits);
 140     ScopedInt b(kFirst, traits);
 141     if (a == b) {
 142     }
 143   }*/
 144
 145   // Implicit conversion to bool shouldn't work.
 146   /*{
 147     ScopedInt a(kFirst, traits);
 148     bool result = a;
 149   }*/
 150 }
 151 #endif
 152
 153 }  // namespace base