2011-01-10 12:56:42 +01:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2010 The Regents of The University of Michigan
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are
|
|
|
|
* met: redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer;
|
|
|
|
* redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution;
|
|
|
|
* neither the name of the copyright holders nor the names of its
|
|
|
|
* contributors may be used to endorse or promote products derived from
|
|
|
|
* this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* Authors: Gabe Black
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <cassert>
|
|
|
|
#include <iostream>
|
|
|
|
#include <list>
|
|
|
|
|
2011-01-18 10:27:04 +01:00
|
|
|
#include "base/cprintf.hh"
|
2011-01-10 12:56:42 +01:00
|
|
|
#include "base/refcnt.hh"
|
2011-01-18 10:27:04 +01:00
|
|
|
#include "unittest/unittest.hh"
|
2011-01-10 12:56:42 +01:00
|
|
|
|
|
|
|
using namespace std;
|
2011-01-18 10:27:04 +01:00
|
|
|
using UnitTest::setCase;
|
2011-01-10 12:56:42 +01:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2011-01-18 10:27:04 +01:00
|
|
|
bool printNewDel = false;
|
|
|
|
|
2011-01-10 12:56:42 +01:00
|
|
|
class TestRC;
|
|
|
|
typedef list<TestRC *> LiveList;
|
|
|
|
LiveList liveList;
|
|
|
|
|
|
|
|
int
|
|
|
|
live()
|
|
|
|
{
|
|
|
|
return liveList.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
liveChange()
|
|
|
|
{
|
|
|
|
static int oldLive = 0;
|
|
|
|
int newLive = live();
|
|
|
|
int diff = newLive - oldLive;
|
|
|
|
oldLive = newLive;
|
|
|
|
return diff;
|
|
|
|
}
|
|
|
|
|
|
|
|
class TestRC : public RefCounted
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
const char *_tag;
|
|
|
|
LiveList::iterator liveIt;
|
|
|
|
|
|
|
|
public:
|
|
|
|
TestRC(const char *newTag) : _tag(newTag)
|
|
|
|
{
|
2011-01-18 10:27:04 +01:00
|
|
|
if (printNewDel)
|
|
|
|
cprintf(" Creating object \"%s\"\n", _tag);
|
2011-01-10 12:56:42 +01:00
|
|
|
liveList.push_front(this);
|
|
|
|
liveIt = liveList.begin();
|
|
|
|
}
|
|
|
|
|
|
|
|
~TestRC()
|
|
|
|
{
|
2011-01-18 10:27:04 +01:00
|
|
|
if (printNewDel)
|
|
|
|
cprintf(" Destroying object \"%s\"\n", _tag);
|
2011-01-10 12:56:42 +01:00
|
|
|
liveList.erase(liveIt);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
tag()
|
|
|
|
{
|
|
|
|
return _tag;
|
|
|
|
}
|
|
|
|
|
|
|
|
int testVal;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef RefCountingPtr<TestRC> Ptr;
|
|
|
|
|
2011-01-18 10:27:04 +01:00
|
|
|
} // anonymous namespace
|
2011-01-10 12:56:42 +01:00
|
|
|
|
|
|
|
int
|
|
|
|
main()
|
|
|
|
{
|
|
|
|
assert(live() == 0);
|
|
|
|
assert(liveChange() == 0);
|
|
|
|
|
|
|
|
// Create an empty Ptr and verify it's data pointer is NULL.
|
2011-01-18 10:27:04 +01:00
|
|
|
setCase("NULL check");
|
2011-01-10 12:56:42 +01:00
|
|
|
Ptr nullCheck;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(nullCheck.get(), NULL);
|
2011-01-10 12:56:42 +01:00
|
|
|
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), 0);
|
2011-01-10 12:56:42 +01:00
|
|
|
|
|
|
|
// Construct a Ptr from a TestRC pointer.
|
2011-01-18 10:27:04 +01:00
|
|
|
setCase("construction from pointer");
|
2011-01-10 12:56:42 +01:00
|
|
|
Ptr constFromPointer = new TestRC("construction from pointer");
|
|
|
|
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), 1);
|
2011-01-10 12:56:42 +01:00
|
|
|
|
|
|
|
// Construct a Ptr from an existing Ptr.
|
2011-01-18 10:27:04 +01:00
|
|
|
setCase("construction from a Ptr");
|
2011-01-10 12:56:42 +01:00
|
|
|
Ptr constFromPtr = constFromPointer;
|
|
|
|
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), 0);
|
2011-01-10 12:56:42 +01:00
|
|
|
|
|
|
|
// Test a Ptr being destroyed.
|
2011-01-18 10:27:04 +01:00
|
|
|
setCase("destroying a Ptr");
|
2011-01-10 12:56:42 +01:00
|
|
|
Ptr *ptrPtr = new Ptr(new TestRC("destroying a ptr"));
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), 1);
|
2011-01-10 12:56:42 +01:00
|
|
|
delete ptrPtr;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), -1);
|
2011-01-10 12:56:42 +01:00
|
|
|
|
|
|
|
// Test assignment from a pointer and from a Ptr.
|
2011-01-18 10:27:04 +01:00
|
|
|
setCase("assignment operators");
|
2011-01-10 12:56:42 +01:00
|
|
|
Ptr assignmentTarget;
|
|
|
|
TestRC *assignmentSourcePointer = new TestRC("assignment source 1");
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), 1);
|
2011-01-10 12:56:42 +01:00
|
|
|
assignmentTarget = assignmentSourcePointer;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), 0);
|
2011-01-10 12:56:42 +01:00
|
|
|
assignmentTarget = NULL;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), -1);
|
2011-01-10 12:56:42 +01:00
|
|
|
Ptr assignmentSourcePtr(new TestRC("assignment source 2"));
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), 1);
|
2011-01-10 12:56:42 +01:00
|
|
|
assignmentTarget = assignmentSourcePtr;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), 0);
|
2011-01-10 12:56:42 +01:00
|
|
|
assignmentSourcePtr = NULL;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), 0);
|
2011-01-10 12:56:42 +01:00
|
|
|
assignmentTarget = NULL;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), -1);
|
2011-01-10 12:56:42 +01:00
|
|
|
|
|
|
|
// Test access to members of the pointed to class and dereferencing.
|
2011-01-18 10:27:04 +01:00
|
|
|
setCase("access to members");
|
2011-01-10 12:56:42 +01:00
|
|
|
TestRC *accessTest = new TestRC("access test");
|
|
|
|
Ptr accessTestPtr = accessTest;
|
|
|
|
accessTest->testVal = 1;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(accessTestPtr->testVal, 1);
|
|
|
|
EXPECT_EQ((*accessTestPtr).testVal, 1);
|
2011-01-10 12:56:42 +01:00
|
|
|
accessTest->testVal = 2;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(accessTestPtr->testVal, 2);
|
|
|
|
EXPECT_EQ((*accessTestPtr).testVal, 2);
|
2011-01-10 12:56:42 +01:00
|
|
|
accessTestPtr->testVal = 3;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(accessTest->testVal, 3);
|
2011-01-10 12:56:42 +01:00
|
|
|
(*accessTestPtr).testVal = 4;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(accessTest->testVal, 4);
|
2011-01-10 12:56:42 +01:00
|
|
|
accessTestPtr = NULL;
|
|
|
|
accessTest = NULL;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(liveChange(), 0);
|
2011-01-10 12:56:42 +01:00
|
|
|
|
|
|
|
// Test bool and ! operator overloads.
|
2011-01-18 10:27:04 +01:00
|
|
|
setCase("conversion to bool and ! overload");
|
2011-01-10 12:56:42 +01:00
|
|
|
Ptr boolTest = new TestRC("bool test");
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(boolTest, true);
|
|
|
|
EXPECT_EQ(!boolTest, false);
|
2011-01-10 12:56:42 +01:00
|
|
|
boolTest = NULL;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_EQ(boolTest, false);
|
|
|
|
EXPECT_EQ(!boolTest, true);
|
|
|
|
EXPECT_EQ(liveChange(), 0);
|
2011-01-10 12:56:42 +01:00
|
|
|
|
|
|
|
// Test the equality operators.
|
2011-01-18 10:27:04 +01:00
|
|
|
setCase("equality operators");
|
2011-01-10 12:56:42 +01:00
|
|
|
TestRC *equalTestA = new TestRC("equal test a");
|
|
|
|
Ptr equalTestAPtr = equalTestA;
|
|
|
|
Ptr equalTestAPtr2 = equalTestA;
|
|
|
|
TestRC *equalTestB = new TestRC("equal test b");
|
|
|
|
Ptr equalTestBPtr = equalTestB;
|
2011-01-18 10:27:04 +01:00
|
|
|
EXPECT_TRUE(equalTestA == equalTestAPtr);
|
|
|
|
EXPECT_TRUE(equalTestAPtr == equalTestA);
|
|
|
|
EXPECT_TRUE(equalTestAPtr == equalTestAPtr2);
|
|
|
|
EXPECT_TRUE(equalTestA != equalTestBPtr);
|
|
|
|
EXPECT_TRUE(equalTestAPtr != equalTestB);
|
|
|
|
EXPECT_TRUE(equalTestAPtr != equalTestBPtr);
|
|
|
|
|
|
|
|
return UnitTest::printResults();
|
2011-01-10 12:56:42 +01:00
|
|
|
}
|