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