libretime/library/propel/test/tree-test.php

427 lines
10 KiB
PHP

<?php
/**
* This file is part of the Propel package.
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*
* @license MIT License
*/
if (!isset($argc)) echo "<pre>";
error_reporting(E_ALL);
$conf_path = realpath(dirname(__FILE__) . '/fixtures/treetest/build/conf/treetest-conf.php');
if (!file_exists($conf_path)) {
echo "Make sure that you specify properties in conf/treetest.properties and "
."build propel before running this script.";
exit;
}
// Add PHP_CLASSPATH, if set
if (getenv("PHP_CLASSPATH")) {
set_include_path(getenv("PHP_CLASSPATH") . PATH_SEPARATOR . get_include_path());
}
// Add build/classes/ and classes/ to path
set_include_path(
realpath(dirname(__FILE__) . '/fixtures/treetest/build/classes') . PATH_SEPARATOR .
dirname(__FILE__) . '/../runtime/classes' . PATH_SEPARATOR .
get_include_path()
);
// Require classes.
require_once 'propel/Propel.php';
require_once 'treetest/TestNodePeer.php';
function dumpTree($node, $querydb = false, $con = null)
{
$opts = array('querydb' => $querydb,
'con' => $con);
$node->setIteratorOptions('pre', $opts);
$indent = 0;
$lastLevel = $node->getNodeLevel();
foreach ($node as $n)
{
$nodeLevel = $n->getNodeLevel();
$indent += $nodeLevel - $lastLevel;
echo str_repeat(' ', $indent);
echo $n->getNodePath() . " -> " . $n->getLabel();
echo "\n";
$lastLevel = $nodeLevel;
}
}
try {
// Initialize Propel
Propel::init($conf_path);
} catch (Exception $e) {
die("Error initializing propel: ". $e->__toString());
}
try {
$nodeKeySep = TestNodePeer::NPATH_SEP;
echo "\nCreating initial tree:\n";
echo "-------------------------------------\n";
$a = new Test();
$a->setLabel("a");
$a = TestNodePeer::createNewRootNode($a);
echo "Created 'a' as new root\n";
$b = new TestNode();
$b->setLabel('b');
$a->addChildNode($b);
echo "Added 'b' as first child of 'a'\n";
$c = new TestNode();
$c->setLabel('c');
$a->addChildNode($c);
echo "Added 'c' as second child of 'a'\n";
$f = new TestNode();
$f->setLabel('f');
$b->addChildNode($f);
echo "Added 'f' as first child of 'b'\n";
$d = new TestNode();
$d->setLabel('d');
$b->addChildNode($d, $f);
echo "Added 'd' as first child of 'b' before 'f' (insert before first child test - f is now second child)\n";
$e = new TestNode();
$e->setLabel('e');
$b->addChildNode($e, $f);
echo "Added 'e' as second child of 'b' before 'f' (insert before last child test - f is now third child)\n";
$g = new TestNode();
$g->setLabel('g');
$c->addChildNode($g);
echo "Added 'g' as first child of 'c'\n";
$h = new TestNode();
$h->setLabel('h');
$c->addChildNode($h);
echo "Added 'h' as second child of 'c'\n";
$i = new TestNode();
$i->setLabel('i');
$d->addChildNode($i);
echo "Added 'i' as first child of 'd'\n";
$j = new TestNode();
$j->setLabel('j');
$f->addChildNode($j);
echo "Added 'j' as first child of 'f'\n";
$k = new TestNode();
$k->setLabel('k');
$j->addChildNode($k);
echo "Added 'k' as first child of 'j'\n";
$l = new TestNode();
$l->setLabel('l');
$j->addChildNode($l);
echo "Added 'l' as second child of 'j'\n";
dumpTree($a);
echo "\n\nDeleting 'd' node sub-tree:\n";
echo "-------------------------------------\n";
$d->delete();
dumpTree($a);
echo "\n\nMove node tests:\n";
echo "-------------------------------------\n";
echo "Move 'j' sub-tree to 'b' before 'e' (move tree/insert before first child test):\n";
$b->addChildNode($j, $e);
dumpTree($a);
echo "\nMove 'j' sub-tree to 'c' (move tree after last child test):\n";
$c->addChildNode($j);
dumpTree($a);
echo "\nMove 'j' sub-tree to 'g' (move tree to first child test):\n";
$g->addChildNode($j);
dumpTree($a);
echo "\n\nCreating new (in-memory) sub-tree:\n";
echo "-------------------------------------\n";
$m = new TestNode();
$m->setLabel('m');
echo "Created 'm' as root of new sub-tree\n";
$n = new TestNode();
$n->setLabel('n');
$m->addChildNode($n);
echo "Added 'n' as first child of 'm'\n";
$o = new TestNode();
$o->setLabel('o');
$m->addChildNode($o);
echo "Added 'o' as second child of 'm'\n";
$r = new TestNode();
$r->setLabel('r');
$n->addChildNode($r);
echo "Added 'r' as first child of 'n'\n";
$p = new TestNode();
$p->setLabel('p');
$n->addChildNode($p, $r);
echo "Added 'p' as first child of 'n' before 'r' (insert before first child test - r is now second child)\n";
$q = new TestNode();
$q->setLabel('q');
$n->addChildNode($q, $r);
echo "Added 'q' as second child of 'n' before 'r' (insert before last child test - r is now third child)\n";
$s = new TestNode();
$s->setLabel('s');
$o->addChildNode($s);
echo "Added 's' as first child of 'o'\n";
$t = new TestNode();
$t->setLabel('t');
$o->addChildNode($t);
echo "Added 't' as second child of 'o'\n";
$u = new TestNode();
$u->setLabel('u');
$p->addChildNode($u);
echo "Added 'u' as first child of 'p'\n";
$v = new TestNode();
$v->setLabel('v');
$r->addChildNode($v);
echo "Added 'v' as first child of 'r'\n";
$w = new TestNode();
$w->setLabel('w');
$v->addChildNode($w);
echo "Added 'w' as first child of 'v'\n";
$x = new TestNode();
$x->setLabel('x');
$v->addChildNode($x);
echo "Added 'x' as second child of 'v'\n";
dumpTree($m);
echo "\n\nDeleting in-memory 'p' node sub-tree:\n";
echo "-------------------------------------\n";
$p->delete();
dumpTree($m);
echo "\n\nMove in-memory node tests:\n";
echo "-------------------------------------\n";
echo "Move 'v' sub-tree to 'n' before 'q' (move tree/insert before first child test):\n";
$n->addChildNode($v, $q);
dumpTree($m);
echo "\nMove 'v' sub-tree to 'o' (move tree after last child test):\n";
$o->addChildNode($v);
dumpTree($m);
echo "\nMove 'v' sub-tree to 's' (move tree to first child test):\n";
$s->addChildNode($v);
dumpTree($m);
echo "\n\nAdd in-memory 'm' sub-tree to 'a':\n";
echo "-------------------------------------\n";
$a->addChildNode($m);
dumpTree($a);
echo "\n\nInsert new root node 'z' and retrieve descendants on demand (via querydb param in iterator):\n";
echo "-------------------------------------\n";
$z = new Test();
$z->setLabel("z");
$z = TestNodePeer::insertNewRootNode($z);
dumpTree($z, true);
} catch (Exception $e) {
die("Error creating initial tree: " . $e->__toString());
}
try {
echo "\n\nTest retrieveRootNode() (without descendants)\n";
echo "-------------------------------------\n";
$root = TestNodePeer::retrieveRootNode(false);
dumpTree($root);
echo "\n\nTest retrieveRootNode() (with descendants)\n";
echo "-------------------------------------\n";
$root = TestNodePeer::retrieveRootNode(true);
dumpTree($root);
$m_addr = array(1,1,3);
echo "\n\nTest retrieveNodeByNP() for 'm' (without descendants)\n";
echo "-------------------------------------\n";
$node = TestNodePeer::retrieveNodeByNP(implode($nodeKeySep, $m_addr), false, false);
dumpTree($node);
echo "\n\nTest retrieveNodeByNP() for 'm' (with descendants)\n";
echo "-------------------------------------\n";
$node = TestNodePeer::retrieveNodeByNP(implode($nodeKeySep, $m_addr), false, true);
dumpTree($node);
echo "\n\nTest getAncestors() for 'x' in one query:\n";
echo "-------------------------------------\n";
$criteria = new Criteria();
$criteria->add(TestPeer::LABEL, 'x', Criteria::EQUAL);
$nodes = TestNodePeer::retrieveNodes($criteria, true, false);
$ancestors = $nodes[0]->getAncestors(false);
foreach ($ancestors as $ancestor)
echo $ancestor->getNodePath() . " -> " . $ancestor->getLabel() . "\n";
echo "\n\nTest retrieveNodeByNP() for 'o' (with ancestors and descendants in one query):\n";
echo "-------------------------------------\n";
$o_addr = array(1,1,3,2);
$node = TestNodePeer::retrieveNodeByNP(implode($nodeKeySep, $o_addr), true, true);
echo "ancestors:\n";
foreach ($node->getAncestors(false) as $ancestor)
echo $ancestor->getNodePath() . " -> " . $ancestor->getLabel() . "\n";
echo "\ndescendants:\n";
dumpTree($node);
echo "\n\nTest retrieveNodes() between 'b' and 'g' (without descendants)\n";
echo "-------------------------------------\n";
$criteria = new Criteria();
$criteria->add(TestPeer::LABEL, 'b', Criteria::GREATER_EQUAL);
$criteria->addAnd(TestPeer::LABEL, 'g', Criteria::LESS_EQUAL);
$criteria->addAscendingOrderByColumn(TestPeer::LABEL);
$nodes = TestNodePeer::retrieveNodes($criteria, false, false);
foreach ($nodes as $node)
echo $node->getNodePath() . " -> " . $node->getLabel() . "\n";
echo "\n\nTest retrieveNodes() between 'b' and 'g' (with descendants)\n";
echo "-------------------------------------\n";
$criteria = new Criteria();
$criteria->add(TestPeer::LABEL, 'b', Criteria::GREATER_EQUAL);
$criteria->addAnd(TestPeer::LABEL, 'g', Criteria::LESS_EQUAL);
$criteria->addAscendingOrderByColumn(TestPeer::LABEL);
$nodes = TestNodePeer::retrieveNodes($criteria, false, true);
foreach ($nodes as $node)
{
dumpTree($node);
echo "\n";
}
} catch (Exception $e) {
die("Error retrieving nodes: " . $e->__toString());
}
try {
echo "\nCreating new tree:\n";
echo "-------------------------------------\n";
$a = new Test();
$a->setLabel("a");
$a = TestNodePeer::createNewRootNode($a);
echo "Created 'a' as new root\n";
echo "\nAdding 10 child nodes:\n";
echo "-------------------------------------\n";
$b = new TestNode();
$b->setLabel('b');
$a->addChildNode($b);
$c = new TestNode();
$c->setLabel('c');
$a->addChildNode($c);
$d = new TestNode();
$d->setLabel('d');
$a->addChildNode($d);
$e = new TestNode();
$e->setLabel('e');
$a->addChildNode($e);
$f = new TestNode();
$f->setLabel('f');
$a->addChildNode($f);
$g = new TestNode();
$g->setLabel('g');
$a->addChildNode($g);
$h = new TestNode();
$h->setLabel('h');
$a->addChildNode($h);
$i = new TestNode();
$i->setLabel('i');
$a->addChildNode($i);
$j = new TestNode();
$j->setLabel('j');
$a->addChildNode($j);
$k = new TestNode();
$k->setLabel('k');
$a->addChildNode($k);
echo "\ndescendants:\n";
dumpTree($a);
echo "\nRetrieving last node:\n";
echo "-------------------------------------\n";
$last = $a->getLastChildNode(true);
echo "Last child node is '" . $last->getLabel() . "' (" . $last->getNodePath() . ")\n";
} catch (Exception $e) {
die("Error creating tree with > 10 nodes: " . $e->__toString());
}
if (!isset($argc)) echo "</pre>";