TreeNode* getNode(const LocationCode<maxLevels>& code)
{
int level = maxLevels;
// FIXME: it's really important to start from root.child (as root is a header) and ALL TESTS
// PASS WHEN IT'S CHANGED TO: `node = &root;`
TreeNode* node = &(root.child(0, 0));
do
{
if (!node->hasChildren() || node == &(node->child(code)))
break;
node = &(node->child(code));
} while (--level);
return node;
}
void TreeNodeTest::test_updateChildList()
{
NRoot::Ptr node(new NRoot("Root"));
NGeneric::Ptr node1(new NGeneric("Node1", "MyType"));
NGeneric::Ptr node2(new NGeneric("Node2", "MyType"));
TreeNode * treeNode;
TreeNode * child;
node->addNode(node1);
treeNode = new TreeNode(node, nullptr, 0);
QCOMPARE( treeNode->childCount(), 1);
node->addNode(node2);
QCOMPARE( treeNode->childCount(), 2);
child = treeNode->child(1);
QVERIFY( child != nullptr );
QCOMPARE( child->nodeName(), QString("Node2"));
delete treeNode;
}
/*---------------------------------------------------------------------*//**
ルートノード取得
**//*---------------------------------------------------------------------*/
MenuTreeNode* Menu::getMenuTreeRootNode() const
{
TreeNode<MenuTreeNode>* tnode = _tree->getRoot();
if(tnode == 0L) { return 0L; }
tnode = tnode->child();
if(tnode == 0L) { return 0L; }
return tnode->object();
}
void Executer::executeFunctionCall(TreeNode* node) {
// //qDebug() << "called";
if (node->parent()->token()->type() == Token::Learn) { // in case we're defining a function
currentNode = node->parent();
executeCurrent = true;
return;
}
if (returning) { // if the function is already executed and returns now
returnValue = 0;
returning = false;
// //qDebug() << "==> functionReturned!";
return;
}
if (!functionTable.contains(node->token()->look())) {
addError(i18n("An unknown function named '%1' was called", node->token()->look()), *node->token(), 0);
return;
}
CalledFunction c;
c.function = node;
c.variableTable = new VariableTable();
functionStack.push(c);
// //qDebug() << "==> functionCalled!";
TreeNode* learnNode = functionTable[node->token()->look()];
// if the parameter numbers are not equal...
if (node->childCount() != learnNode->child(1)->childCount()) {
addError(
i18n("The function '%1' was called with %2, while it should be called with %3",
node->token()->look(),
i18ncp("The function '%1' was called with %2, while it should be called with %3", "1 parameter", "%1 parameters", node->childCount()),
i18ncp("The function '%1' was called with %2, while it should be called with %3", "1 parameter", "%1 parameters", learnNode->child(1)->childCount())
),
*node->token(), 0);
return;
}
for (uint i = 0; i < node->childCount(); i++) {
functionStack.top().variableTable->insert(learnNode->child(1)->child(i)->token()->look(), node->child(i)->value());
// //qDebug() << "inserted variable " << learnNode->child(1)->child(i)->token()->look() << " on function stack";
}
newScope = learnNode->child(2);
}
int main(int argc, char* argv[])
{
Timer::instance.start();
cerr << "R " << argv[0] << endl;
cerr << "RAND_MAX = " << RAND_MAX << endl;
cerr << "sizeof(bool) = " << sizeof(bool) << endl;
cerr << "sizeof(uint) = " << sizeof(uint) << endl;
cerr << "sizeof(uint64) = " << sizeof(uint64) << endl;
cerr << "sizeof(uint128) = " << sizeof(uint128) << endl;
cerr << "sizeof(void*) = " << sizeof(void*) << endl;
cerr << "sizeof(std::size_t) = " << sizeof(std::size_t) << endl;
cerr << "sizeof(Rotation) = " << sizeof(Rotation) << endl;
cerr << "sizeof(SymmetryGroup) = " << sizeof(SymmetryGroup) << endl;
cerr << "sizeof(BoardPoint) = " << sizeof(BoardPoint) << endl;
cerr << "sizeof(Move) = " << sizeof(Move) << endl;
cerr << "sizeof(BoardMask) = " << sizeof(BoardMask) << endl;
cerr << "sizeof(Board) = " << sizeof(Board) << endl;
cerr << "sizeof(BoardNode) = " << sizeof(BoardNode) << endl;
cerr << "sizeof(BoardNode::OrientedBoardNode) = " << sizeof(BoardNode::OrientedBoardNode) << endl;
cerr << "sizeof(TreeNode) = " << sizeof(TreeNode) << endl;
srand(time(0));
BoardNode::initialize();
BoardMask::initialize();
assert(BoardNode::fragmentCount() == 37);
cerr << "Initialized" << endl;
TreeNode root;
TreeNode* node = &root;
//root.loadGames("games.txt");
for(uint i = 0; i < 50; ++i) {
for(uint j = 0; j < 1000; ++j)
node->mcts();
Move bestMove = node->bestMove();
node = node->child(bestMove);
assert(node != nullptr);
}
cerr << "Treenodes: " << TreeNode::numNodes() << endl;
BoardNode::dumpHisto();
ofstream stats("stats.csv");
BoardNode::dumpStats(stats);
return 0;
GameInputOutput gio;
gio.run();
cerr << "Exit" << endl;
Timer::instance.stop();
return 0;
}
iterator insert(StoredObject&& toStore)
{
TreeNode* node = getNode(toStore.location);
if (node->level() > 0)
{
// We store one element at time so there will be a moment before node overflow when its
// count will be equal capacity. Then we'll relocate all its elements to the new child
// nodes. At worst scenario, all elements will be relocated to the same node, so its
// count() will be again equal to capacity. The loop ends when at least one element is
// relocated to the another child node.
while (node->count() == nodeCapacity && node->level() > 0)
{
typename TreeNode::iterator it;
typename TreeNode::iterator itEnd = node->end();
for (it = node->begin(); it != itEnd; ++it)
{
node->child(it->location).insert(std::move(*it));
}
node->clear();
node = &(node->child(toStore.location));
}
}
return iterator(node, node->insert(std::move(toStore)));
}
void TreeNodeTest::test_child()
{
/*
The tree we will work with:
Root
|----> Node1
| |----> Node11
| |----> Node12
|
|----> Node2
| |----> Node21
| |----> Node22
| |----> Node23
|
|----> Node3
*/
NRoot::Ptr node(new NRoot("Root"));
NGeneric::Ptr node1(new NGeneric("Node1", "MyType"));
NGeneric::Ptr node11(new NGeneric("Node11", "MyType"));
NGeneric::Ptr node12(new NGeneric("Node12", "MyType"));
NGeneric::Ptr node2(new NGeneric("Node2", "MyType"));
NGeneric::Ptr node21(new NGeneric("Node21", "MyType"));
NGeneric::Ptr node22(new NGeneric("Node22", "MyType"));
NGeneric::Ptr node23(new NGeneric("Node23", "MyType"));
NGeneric::Ptr node3(new NGeneric("Node3", "MyType"));
TreeNode * treeNode = nullptr;
TreeNode * treeNode1 = nullptr;
TreeNode * treeNode11 = nullptr;
TreeNode * treeNode12 = nullptr;
TreeNode * treeNode2 = nullptr;
TreeNode * treeNode21 = nullptr;
TreeNode * treeNode22 = nullptr;
TreeNode * treeNode23 = nullptr;
TreeNode * treeNode3 = nullptr;
node->addNode(node1);
node->addNode(node2);
node->addNode(node3);
node1->addNode(node11);
node1->addNode(node12);
node2->addNode(node21);
node2->addNode(node22);
node2->addNode(node23);
treeNode = new TreeNode(node, nullptr, 0);
//
// 1. check the direct children
//
treeNode1 = treeNode->child(0);
treeNode2 = treeNode->child(1);
treeNode3 = treeNode->child(2);
// check that pointer are not null
QVERIFY( treeNode1 != (TreeNode*) nullptr );
QVERIFY( treeNode2 != (TreeNode*) nullptr );
QVERIFY( treeNode3 != (TreeNode*) nullptr );
// their parent should be the root
QCOMPARE( treeNode1->parentNode(), treeNode );
QCOMPARE( treeNode2->parentNode(), treeNode );
QCOMPARE( treeNode3->parentNode(), treeNode );
// check their name
QCOMPARE( treeNode1->nodeName(), QString("Node1") );
QCOMPARE( treeNode2->nodeName(), QString("Node2") );
QCOMPARE( treeNode3->nodeName(), QString("Node3") );
//
// 2. children of Node1
//
treeNode11 = treeNode1->child(0);
treeNode12 = treeNode1->child(1);
// check that pointer are not null
QVERIFY( treeNode11 != (TreeNode*) nullptr );
QVERIFY( treeNode12 != (TreeNode*) nullptr );
// their parent should be the root
QCOMPARE( treeNode11->parentNode(), treeNode1 );
QCOMPARE( treeNode12->parentNode(), treeNode1 );
// check their name
QCOMPARE( treeNode11->nodeName(), QString("Node11") );
QCOMPARE( treeNode12->nodeName(), QString("Node12") );
//
// 3. children of Node2
//
treeNode21 = treeNode2->child(0);
treeNode22 = treeNode2->child(1);
treeNode23 = treeNode2->child(2);
// check that pointer are not null
QVERIFY( treeNode21 != (TreeNode*) nullptr );
QVERIFY( treeNode22 != (TreeNode*) nullptr );
QVERIFY( treeNode23 != (TreeNode*) nullptr );
// their parent should be the root
QCOMPARE( treeNode21->parentNode(), treeNode2 );
QCOMPARE( treeNode22->parentNode(), treeNode2 );
QCOMPARE( treeNode23->parentNode(), treeNode2 );
// check their name
QCOMPARE( treeNode21->nodeName(), QString("Node21") );
QCOMPARE( treeNode22->nodeName(), QString("Node22") );
QCOMPARE( treeNode23->nodeName(), QString("Node23") );
//
// 4. no child for Node3 (should return nullptr)
//
QCOMPARE( treeNode3->child(0), (TreeNode*) nullptr );
delete treeNode; // deletes the children as well
}
void TreeNodeTest::test_childByName()
{
// same tree as for test_child()
NRoot::Ptr node(new NRoot("Root"));
NGeneric::Ptr node1(new NGeneric("Node1", "MyType"));
NGeneric::Ptr node11(new NGeneric("Node11", "MyType"));
NGeneric::Ptr node12(new NGeneric("Node12", "MyType"));
NGeneric::Ptr node2(new NGeneric("Node2", "MyType"));
NGeneric::Ptr node21(new NGeneric("Node21", "MyType"));
NGeneric::Ptr node22(new NGeneric("Node22", "MyType"));
NGeneric::Ptr node23(new NGeneric("Node23", "MyType"));
NGeneric::Ptr node3(new NGeneric("Node3", "MyType"));
TreeNode * treeNode = nullptr;
TreeNode * treeNode1 = nullptr;
TreeNode * treeNode11 = nullptr;
TreeNode * treeNode12 = nullptr;
TreeNode * treeNode2 = nullptr;
TreeNode * treeNode21 = nullptr;
TreeNode * treeNode22 = nullptr;
TreeNode * treeNode23 = nullptr;
TreeNode * treeNode3 = nullptr;
node->addNode(node1);
node->addNode(node2);
node->addNode(node3);
node1->addNode(node11);
node1->addNode(node12);
node2->addNode(node21);
node2->addNode(node22);
node2->addNode(node23);
treeNode = new TreeNode(node, nullptr, 0);
treeNode1 = treeNode->child(0);
treeNode11 = treeNode1->child(0);
treeNode12 = treeNode1->child(1);
treeNode2 = treeNode->child(1);
treeNode21 = treeNode2->child(0);
treeNode22 = treeNode2->child(1);
treeNode23 = treeNode2->child(2);
treeNode3 = treeNode->child(2);
//
// 1. check the direct children
//
treeNode1 = treeNode->childByName("Node1");
treeNode2 = treeNode->childByName("Node2");
treeNode3 = treeNode->childByName("Node3");
// check that pointer are not null
QVERIFY( treeNode1 != (TreeNode*) nullptr );
QVERIFY( treeNode2 != (TreeNode*) nullptr );
QVERIFY( treeNode3 != (TreeNode*) nullptr );
// their parent should be the root
QCOMPARE( treeNode1->parentNode(), treeNode );
QCOMPARE( treeNode2->parentNode(), treeNode );
QCOMPARE( treeNode3->parentNode(), treeNode );
// check their row number
QCOMPARE( treeNode1->rowNumber(), 0 );
QCOMPARE( treeNode2->rowNumber(), 1 );
QCOMPARE( treeNode3->rowNumber(), 2 );
//
// 2. children of Node1
//
treeNode11 = treeNode1->childByName("Node11");
treeNode12 = treeNode1->childByName("Node12");
// check that pointer are not null
QVERIFY( treeNode11 != (TreeNode*) nullptr );
QVERIFY( treeNode12 != (TreeNode*) nullptr );
// their parent should be the root
QCOMPARE( treeNode11->parentNode(), treeNode1 );
QCOMPARE( treeNode12->parentNode(), treeNode1 );
// check their row number
QCOMPARE( treeNode11->rowNumber(), 0 );
QCOMPARE( treeNode12->rowNumber(), 1 );
//
// 3. wrong name
//
QCOMPARE ( treeNode2->childByName("Node"), (TreeNode*) nullptr );
delete treeNode; // deletes the children as well
}
