2014-01-03 20:14:03 +08:00
|
|
|
#include "UnitTest.h"
|
|
|
|
|
|
|
|
// For ' < o > ' multiply test scene.
|
|
|
|
|
|
|
|
static std::function<Layer*()> createFunctions[] = {
|
|
|
|
CL(TemplateVectorTest),
|
2014-01-03 21:06:33 +08:00
|
|
|
CL(TemplateMapTest),
|
|
|
|
CL(ValueTest)
|
2014-01-03 20:14:03 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static int sceneIdx = -1;
|
|
|
|
static const int MAX_LAYER = (sizeof(createFunctions) / sizeof(createFunctions[0]));
|
|
|
|
|
|
|
|
static Layer* nextAction()
|
|
|
|
{
|
|
|
|
sceneIdx++;
|
|
|
|
sceneIdx = sceneIdx % MAX_LAYER;
|
|
|
|
|
|
|
|
auto layer = (createFunctions[sceneIdx])();
|
|
|
|
return layer;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Layer* backAction()
|
|
|
|
{
|
|
|
|
sceneIdx--;
|
|
|
|
int total = MAX_LAYER;
|
|
|
|
if( sceneIdx < 0 )
|
|
|
|
sceneIdx += total;
|
|
|
|
|
|
|
|
auto layer = (createFunctions[sceneIdx])();
|
|
|
|
return layer;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Layer* restartAction()
|
|
|
|
{
|
|
|
|
auto layer = (createFunctions[sceneIdx])();
|
|
|
|
return layer;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitTestScene::runThisTest()
|
|
|
|
{
|
|
|
|
sceneIdx = -1;
|
|
|
|
addChild(nextAction());
|
|
|
|
Director::getInstance()->replaceScene(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitTestDemo::onEnter()
|
|
|
|
{
|
|
|
|
BaseTest::onEnter();
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitTestDemo::onExit()
|
|
|
|
{
|
|
|
|
BaseTest::onExit();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string UnitTestDemo::title() const
|
|
|
|
{
|
|
|
|
return "UnitTest";
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string UnitTestDemo::subtitle() const
|
|
|
|
{
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2014-02-20 10:53:49 +08:00
|
|
|
void UnitTestDemo::restartCallback(Ref* sender)
|
2014-01-03 20:14:03 +08:00
|
|
|
{
|
|
|
|
auto s = new UnitTestScene();
|
|
|
|
s->addChild( restartAction() );
|
|
|
|
Director::getInstance()->replaceScene(s);
|
|
|
|
s->release();
|
|
|
|
}
|
|
|
|
|
2014-02-20 10:53:49 +08:00
|
|
|
void UnitTestDemo::nextCallback(Ref* sender)
|
2014-01-03 20:14:03 +08:00
|
|
|
{
|
|
|
|
auto s = new UnitTestScene();
|
|
|
|
s->addChild( nextAction() );
|
|
|
|
Director::getInstance()->replaceScene(s);
|
|
|
|
s->release();
|
|
|
|
}
|
|
|
|
|
2014-02-20 10:53:49 +08:00
|
|
|
void UnitTestDemo::backCallback(Ref* sender)
|
2014-01-03 20:14:03 +08:00
|
|
|
{
|
|
|
|
auto s = new UnitTestScene();
|
|
|
|
s->addChild( backAction() );
|
|
|
|
Director::getInstance()->replaceScene(s);
|
|
|
|
s->release();
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
|
|
|
|
void TemplateVectorTest::onEnter()
|
|
|
|
{
|
|
|
|
UnitTestDemo::onEnter();
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
Vector<Node*> vec;
|
|
|
|
CCASSERT(vec.empty(), "");
|
|
|
|
CCASSERT(vec.capacity() == 0, "");
|
|
|
|
CCASSERT(vec.size() == 0, "");
|
|
|
|
CCASSERT(vec.max_size() > 0, "");
|
|
|
|
|
|
|
|
auto node1 = Node::create();
|
|
|
|
node1->setTag(1);
|
|
|
|
vec.pushBack(node1);
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(node1->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
|
|
|
|
auto node2 = Node::create();
|
|
|
|
node2->setTag(2);
|
|
|
|
vec.pushBack(node2);
|
|
|
|
CCASSERT(vec.getIndex(node1) == 0, "");
|
|
|
|
CCASSERT(vec.getIndex(node2) == 1, "");
|
|
|
|
|
|
|
|
auto node3 = Node::create();
|
|
|
|
node3->setTag(3);
|
|
|
|
vec.insert(1, node3);
|
|
|
|
CCASSERT(vec.at(0)->getTag() == 1, "");
|
|
|
|
CCASSERT(vec.at(1)->getTag() == 3, "");
|
|
|
|
CCASSERT(vec.at(2)->getTag() == 2, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Test copy constructor
|
|
|
|
Vector<Node*> vec2(vec);
|
|
|
|
CCASSERT(vec2.size() == vec.size(), "");
|
|
|
|
ssize_t size = vec.size();
|
|
|
|
for (ssize_t i = 0; i < size; ++i)
|
|
|
|
{
|
|
|
|
CCASSERT(vec2.at(i) == vec.at(i), "");
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(vec.at(i)->getReferenceCount() == 3, "");
|
|
|
|
CCASSERT(vec2.at(i)->getReferenceCount() == 3, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Test copy assignment operator
|
|
|
|
Vector<Node*> vec3;
|
|
|
|
vec3 = vec2;
|
|
|
|
CCASSERT(vec3.size() == vec2.size(), "");
|
|
|
|
size = vec3.size();
|
|
|
|
for (ssize_t i = 0; i < size; ++i)
|
|
|
|
{
|
|
|
|
CCASSERT(vec3.at(i) == vec2.at(i), "");
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(vec3.at(i)->getReferenceCount() == 4, "");
|
|
|
|
CCASSERT(vec2.at(i)->getReferenceCount() == 4, "");
|
|
|
|
CCASSERT(vec.at(i)->getReferenceCount() == 4, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Test move constructor
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-04 11:44:29 +08:00
|
|
|
auto createVector = [this](){
|
2014-01-03 20:14:03 +08:00
|
|
|
Vector<Node*> ret;
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
for (int i = 0; i < 20; i++)
|
|
|
|
{
|
|
|
|
ret.pushBack(Node::create());
|
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
int j = 1000;
|
|
|
|
for (auto& child : ret)
|
|
|
|
{
|
|
|
|
child->setTag(j++);
|
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
return ret;
|
|
|
|
};
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
Vector<Node*> vec4(createVector());
|
|
|
|
for (const auto& child : vec4)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(child->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Test init Vector<T> with capacity
|
|
|
|
Vector<Node*> vec5(10);
|
|
|
|
CCASSERT(vec5.capacity() == 10, "");
|
|
|
|
vec5.reserve(20);
|
|
|
|
CCASSERT(vec5.capacity() == 20, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
CCASSERT(vec5.size() == 0, "");
|
|
|
|
CCASSERT(vec5.empty(), "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
auto toRemovedNode = Node::create();
|
|
|
|
vec5.pushBack(toRemovedNode);
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(toRemovedNode->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
|
|
|
|
// Test move assignment operator
|
|
|
|
vec5 = createVector();
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(toRemovedNode->getReferenceCount() == 1, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
CCASSERT(vec5.size() == 20, "size should be 20");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
for (const auto& child : vec5)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(child->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Test Vector<T>::find
|
|
|
|
CCASSERT(vec.find(node3) == (vec.begin() + 1), "");
|
|
|
|
CCASSERT(std::find(std::begin(vec), std::end(vec), node2) == (vec.begin() + 2), "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
CCASSERT(vec.front()->getTag() == 1, "");
|
|
|
|
CCASSERT(vec.back()->getTag() == 2, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
CCASSERT(vec.getRandomObject(), "");
|
|
|
|
CCASSERT(!vec.contains(Node::create()), "");
|
|
|
|
CCASSERT(vec.contains(node1), "");
|
|
|
|
CCASSERT(vec.contains(node2), "");
|
|
|
|
CCASSERT(vec.contains(node3), "");
|
|
|
|
CCASSERT(vec.equals(vec2), "");
|
|
|
|
CCASSERT(vec.equals(vec3), "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Insert
|
|
|
|
vec5.insert(2, node1);
|
|
|
|
CCASSERT(vec5.at(2)->getTag() == 1, "");
|
|
|
|
CCASSERT(vec5.size() == 21, "");
|
|
|
|
vec5.back()->setTag(100);
|
|
|
|
vec5.popBack();
|
|
|
|
CCASSERT(vec5.size() == 20, "");
|
|
|
|
CCASSERT(vec5.back()->getTag() != 100, "");
|
|
|
|
|
|
|
|
// Erase and clear
|
|
|
|
Vector<Node*> vec6 = createVector();
|
|
|
|
Vector<Node*> vec7 = vec6; // Copy for check
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
CCASSERT(vec6.size() == 20, "");
|
|
|
|
vec6.erase(vec6.begin() + 1); //
|
|
|
|
CCASSERT(vec6.size() == 19, "");
|
|
|
|
CCASSERT((*(vec6.begin() + 1))->getTag() == 1002, "");
|
|
|
|
vec6.erase(vec6.begin() + 2, vec6.begin() + 10);
|
|
|
|
CCASSERT(vec6.size() == 11, "");
|
|
|
|
CCASSERT(vec6.at(0)->getTag() == 1000, "");
|
|
|
|
CCASSERT(vec6.at(1)->getTag() == 1002, "");
|
|
|
|
CCASSERT(vec6.at(2)->getTag() == 1011, "");
|
|
|
|
CCASSERT(vec6.at(3)->getTag() == 1012, "");
|
|
|
|
vec6.erase(3);
|
|
|
|
CCASSERT(vec6.at(3)->getTag() == 1013, "");
|
|
|
|
vec6.eraseObject(vec6.at(2));
|
|
|
|
CCASSERT(vec6.at(2)->getTag() == 1013, "");
|
|
|
|
vec6.clear();
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Check the retain count in vec7
|
|
|
|
CCASSERT(vec7.size() == 20, "");
|
|
|
|
for (const auto& child : vec7)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(child->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Sort
|
|
|
|
Vector<Node*> vecForSort = createVector();
|
|
|
|
std::sort(vecForSort.begin(), vecForSort.end(), [](Node* a, Node* b){
|
|
|
|
return a->getTag() >= b->getTag();
|
|
|
|
});
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
for (int i = 0; i < 20; ++i)
|
|
|
|
{
|
|
|
|
CCASSERT(vecForSort.at(i)->getTag() - 1000 == (19 - i), "");
|
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Reverse
|
|
|
|
vecForSort.reverse();
|
|
|
|
for (int i = 0; i < 20; ++i)
|
|
|
|
{
|
|
|
|
CCASSERT(vecForSort.at(i)->getTag() - 1000 == i, "");
|
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Swap
|
|
|
|
Vector<Node*> vecForSwap = createVector();
|
|
|
|
vecForSwap.swap(2, 4);
|
|
|
|
CCASSERT(vecForSwap.at(2)->getTag() == 1004, "");
|
|
|
|
CCASSERT(vecForSwap.at(4)->getTag() == 1002, "");
|
|
|
|
vecForSwap.swap(vecForSwap.at(2), vecForSwap.at(4));
|
|
|
|
CCASSERT(vecForSwap.at(2)->getTag() == 1002, "");
|
|
|
|
CCASSERT(vecForSwap.at(4)->getTag() == 1004, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// shrinkToFit
|
|
|
|
Vector<Node*> vecForShrink = createVector();
|
|
|
|
vecForShrink.reserve(100);
|
|
|
|
CCASSERT(vecForShrink.capacity() == 100, "");
|
|
|
|
vecForShrink.pushBack(Node::create());
|
|
|
|
vecForShrink.shrinkToFit();
|
|
|
|
CCASSERT(vecForShrink.capacity() == 21, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// get random object
|
|
|
|
// Set the seed by time
|
|
|
|
srand(time(nullptr));
|
|
|
|
Vector<Node*> vecForRandom = createVector();
|
|
|
|
log("<--- begin ---->");
|
|
|
|
for (int i = 0; i < vecForRandom.size(); ++i)
|
|
|
|
{
|
|
|
|
log("Vector: random object tag = %d", vecForRandom.getRandomObject()->getTag());
|
|
|
|
}
|
|
|
|
log("<---- end ---->");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Self assignment
|
|
|
|
Vector<Node*> vecSelfAssign = createVector();
|
|
|
|
vecSelfAssign = vecSelfAssign;
|
|
|
|
CCASSERT(vecSelfAssign.size() == 20, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
for (const auto& child : vecSelfAssign)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(child->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
vecSelfAssign = std::move(vecSelfAssign);
|
|
|
|
CCASSERT(vecSelfAssign.size() == 20, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
for (const auto& child : vecSelfAssign)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(child->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// const at
|
|
|
|
Vector<Node*> vecConstAt = createVector();
|
|
|
|
constFunc(vecConstAt);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TemplateVectorTest::constFunc(const Vector<Node*>& vec) const
|
|
|
|
{
|
|
|
|
log("vec[8] = %d", vec.at(8)->getTag());
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string TemplateVectorTest::subtitle() const
|
|
|
|
{
|
|
|
|
return "Vector<T>, should not crash";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
|
|
|
|
void TemplateMapTest::onEnter()
|
|
|
|
{
|
|
|
|
UnitTestDemo::onEnter();
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-04 11:44:29 +08:00
|
|
|
auto createMap = [this](){
|
2014-01-03 20:14:03 +08:00
|
|
|
Map<std::string, Node*> ret;
|
|
|
|
for (int i = 0; i < 20; ++i)
|
|
|
|
{
|
|
|
|
auto node = Node::create();
|
|
|
|
node->setTag(1000 + i);
|
|
|
|
ret.insert(StringUtils::toString(i), node);
|
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
return ret;
|
|
|
|
};
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Default constructor
|
|
|
|
Map<std::string, Node*> map1;
|
|
|
|
CCASSERT(map1.empty(), "");
|
|
|
|
CCASSERT(map1.size() == 0, "");
|
|
|
|
CCASSERT(map1.keys().empty(), "");
|
|
|
|
CCASSERT(map1.keys(Node::create()).empty(), "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Move constructor
|
|
|
|
Map<std::string, Node*> map2 = createMap();
|
|
|
|
for (const auto& e : map2)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(e.second->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Copy constructor
|
|
|
|
Map<std::string, Node*> map3(map2);
|
|
|
|
for (const auto& e : map3)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(e.second->getReferenceCount() == 3, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Move assignment operator
|
|
|
|
Map<std::string, Node*> map4;
|
|
|
|
auto unusedNode = Node::create();
|
|
|
|
map4.insert("unused",unusedNode);
|
|
|
|
map4 = createMap();
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(unusedNode->getReferenceCount() == 1, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
for (const auto& e : map4)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(e.second->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Copy assignment operator
|
|
|
|
Map<std::string, Node*> map5;
|
|
|
|
map5 = map4;
|
|
|
|
for (const auto& e : map5)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(e.second->getReferenceCount() == 3, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Check size
|
|
|
|
CCASSERT(map4.size() == map5.size(), "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
for (const auto& e : map4)
|
|
|
|
{
|
|
|
|
CCASSERT(e.second == map5.find(e.first)->second, "");
|
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// bucket_count, bucket_size(n), bucket
|
|
|
|
log("--------------");
|
|
|
|
log("bucket_count = %d", static_cast<int>(map4.bucketCount()));
|
|
|
|
log("size = %d", static_cast<int>(map4.size()));
|
|
|
|
for (int i = 0; i < map4.bucketCount(); ++i)
|
|
|
|
{
|
|
|
|
log("bucket_size(%d) = %d", i, static_cast<int>(map4.bucketSize(i)));
|
|
|
|
}
|
|
|
|
for (const auto& e : map4)
|
|
|
|
{
|
|
|
|
log("bucket(\"%s\"), bucket index = %d", e.first.c_str(), static_cast<int>(map4.bucket(e.first)));
|
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
log("----- all keys---------");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// keys and at
|
|
|
|
auto keys = map4.keys();
|
|
|
|
for (const auto& key : keys)
|
|
|
|
{
|
|
|
|
log("key = %s", key.c_str());
|
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
auto node10Key = map4.at("10");
|
|
|
|
map4.insert("100", node10Key);
|
|
|
|
map4.insert("101", node10Key);
|
|
|
|
map4.insert("102", node10Key);
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
log("------ keys for object --------");
|
|
|
|
auto keysForObject = map4.keys(node10Key);
|
|
|
|
for (const auto& key : keysForObject)
|
|
|
|
{
|
|
|
|
log("key = %s", key.c_str());
|
|
|
|
}
|
|
|
|
log("--------------");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// at in const function
|
|
|
|
constFunc(map4);
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// find
|
|
|
|
auto nodeToFind = map4.find("10");
|
|
|
|
CCASSERT(nodeToFind->second->getTag() == 1010, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// insert
|
|
|
|
Map<std::string, Node*> map6;
|
|
|
|
auto node1 = Node::create();
|
|
|
|
node1->setTag(101);
|
|
|
|
auto node2 = Node::create();
|
|
|
|
node2->setTag(102);
|
|
|
|
auto node3 = Node::create();
|
|
|
|
node3->setTag(103);
|
|
|
|
map6.insert("insert01", node1);
|
|
|
|
map6.insert("insert02", node2);
|
|
|
|
map6.insert("insert03", node3);
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(node1->getReferenceCount() == 2, "");
|
|
|
|
CCASSERT(node2->getReferenceCount() == 2, "");
|
|
|
|
CCASSERT(node3->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
CCASSERT(map6.at("insert01") == node1, "");
|
|
|
|
CCASSERT(map6.at("insert02") == node2, "");
|
|
|
|
CCASSERT(map6.at("insert03") == node3, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// erase
|
|
|
|
Map<std::string, Node*> mapForErase = createMap();
|
|
|
|
mapForErase.erase(mapForErase.find("9"));
|
|
|
|
CCASSERT(mapForErase.find("9") == mapForErase.end(), "");
|
|
|
|
CCASSERT(mapForErase.size() == 19, "");
|
|
|
|
|
|
|
|
mapForErase.erase("7");
|
|
|
|
CCASSERT(mapForErase.find("7") == mapForErase.end(), "");
|
|
|
|
CCASSERT(mapForErase.size() == 18, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
std::vector<std::string> itemsToRemove;
|
|
|
|
itemsToRemove.push_back("2");
|
|
|
|
itemsToRemove.push_back("3");
|
|
|
|
itemsToRemove.push_back("4");
|
|
|
|
mapForErase.erase(itemsToRemove);
|
|
|
|
CCASSERT(mapForErase.size() == 15, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// clear
|
|
|
|
Map<std::string, Node*> mapForClear = createMap();
|
|
|
|
auto mapForClearCopy = mapForClear;
|
|
|
|
mapForClear.clear();
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
for (const auto& e : mapForClearCopy)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(e.second->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// get random object
|
|
|
|
// Set the seed by time
|
|
|
|
srand(time(nullptr));
|
|
|
|
Map<std::string, Node*> mapForRandom = createMap();
|
|
|
|
log("<--- begin ---->");
|
|
|
|
for (int i = 0; i < mapForRandom.size(); ++i)
|
|
|
|
{
|
|
|
|
log("Map: random object tag = %d", mapForRandom.getRandomObject()->getTag());
|
|
|
|
}
|
|
|
|
log("<---- end ---->");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
// Self assignment
|
|
|
|
Map<std::string, Node*> mapForSelfAssign = createMap();
|
|
|
|
mapForSelfAssign = mapForSelfAssign;
|
|
|
|
CCASSERT(mapForSelfAssign.size() == 20, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
for (const auto& e : mapForSelfAssign)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(e.second->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
mapForSelfAssign = std::move(mapForSelfAssign);
|
|
|
|
CCASSERT(mapForSelfAssign.size() == 20, "");
|
2014-01-03 20:20:40 +08:00
|
|
|
|
2014-01-03 20:14:03 +08:00
|
|
|
for (const auto& e : mapForSelfAssign)
|
|
|
|
{
|
2014-01-22 13:47:29 +08:00
|
|
|
CCASSERT(e.second->getReferenceCount() == 2, "");
|
2014-01-03 20:14:03 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TemplateMapTest::constFunc(const Map<std::string, Node*>& map) const
|
|
|
|
{
|
|
|
|
log("[%s]=(tag)%d", "0", map.at("0")->getTag());
|
|
|
|
log("[%s]=(tag)%d", "1", map.find("1")->second->getTag());
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string TemplateMapTest::subtitle() const
|
|
|
|
{
|
|
|
|
return "Map<K, V>, should not crash";
|
|
|
|
}
|
|
|
|
|
2014-01-03 21:06:33 +08:00
|
|
|
//----------------------------------
|
|
|
|
|
|
|
|
void ValueTest::onEnter()
|
|
|
|
{
|
|
|
|
UnitTestDemo::onEnter();
|
|
|
|
|
|
|
|
Value v1;
|
|
|
|
CCASSERT(v1.getType() == Value::Type::NONE, "");
|
|
|
|
CCASSERT(v1.isNull(), "");
|
|
|
|
|
|
|
|
Value v2(100);
|
|
|
|
CCASSERT(v2.getType() == Value::Type::INTEGER, "");
|
|
|
|
CCASSERT(!v2.isNull(), "");
|
|
|
|
|
|
|
|
Value v3(101.4f);
|
|
|
|
CCASSERT(v3.getType() == Value::Type::FLOAT, "");
|
|
|
|
CCASSERT(!v3.isNull(), "");
|
|
|
|
|
|
|
|
Value v4(106.1);
|
|
|
|
CCASSERT(v4.getType() == Value::Type::DOUBLE, "");
|
|
|
|
CCASSERT(!v4.isNull(), "");
|
|
|
|
|
|
|
|
unsigned char byte = 50;
|
|
|
|
Value v5(byte);
|
|
|
|
CCASSERT(v5.getType() == Value::Type::BYTE, "");
|
|
|
|
CCASSERT(!v5.isNull(), "");
|
|
|
|
|
|
|
|
Value v6(true);
|
|
|
|
CCASSERT(v6.getType() == Value::Type::BOOLEAN, "");
|
|
|
|
CCASSERT(!v6.isNull(), "");
|
|
|
|
|
|
|
|
Value v7("string");
|
|
|
|
CCASSERT(v7.getType() == Value::Type::STRING, "");
|
|
|
|
CCASSERT(!v7.isNull(), "");
|
|
|
|
|
|
|
|
Value v8(std::string("string2"));
|
|
|
|
CCASSERT(v8.getType() == Value::Type::STRING, "");
|
|
|
|
CCASSERT(!v8.isNull(), "");
|
|
|
|
|
|
|
|
auto createValueVector = [&](){
|
|
|
|
ValueVector ret;
|
|
|
|
ret.push_back(v1);
|
|
|
|
ret.push_back(v2);
|
|
|
|
ret.push_back(v3);
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
Value v9(createValueVector());
|
|
|
|
CCASSERT(v9.getType() == Value::Type::VECTOR, "");
|
|
|
|
CCASSERT(!v9.isNull(), "");
|
|
|
|
|
|
|
|
auto createValueMap = [&](){
|
|
|
|
ValueMap ret;
|
|
|
|
ret["aaa"] = v1;
|
|
|
|
ret["bbb"] = v2;
|
|
|
|
ret["ccc"] = v3;
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
|
|
|
Value v10(createValueMap());
|
|
|
|
CCASSERT(v10.getType() == Value::Type::MAP, "");
|
|
|
|
CCASSERT(!v10.isNull(), "");
|
|
|
|
|
|
|
|
auto createValueMapIntKey = [&](){
|
|
|
|
ValueMapIntKey ret;
|
|
|
|
ret[111] = v1;
|
|
|
|
ret[222] = v2;
|
|
|
|
ret[333] = v3;
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
|
|
|
Value v11(createValueMapIntKey());
|
|
|
|
CCASSERT(v11.getType() == Value::Type::INT_KEY_MAP, "");
|
|
|
|
CCASSERT(!v11.isNull(), "");
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string ValueTest::subtitle() const
|
|
|
|
{
|
|
|
|
return "Value Test, should not crash";
|
|
|
|
}
|
|
|
|
|
|
|
|
void ValueTest::constFunc(const Value& value) const
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|