[Summary view] [Print] [Text view]

   1  <?php
   2  /*
   3   * Limb PHP Framework
   4   *
   5   * @link http://limb-project.com 
   6   * @copyright  Copyright &copy; 2004-2007 BIT(http://bit-creative.com)
   7   * @license    LGPL http://www.gnu.org/copyleft/lesser.html 
   8   */
   9  lmb_require('limb/toolkit/src/lmbToolkitTools.interface.php');
  10  lmb_require('limb/toolkit/src/lmbAbstractTools.class.php');
  11  lmb_require('limb/toolkit/src/lmbToolkit.class.php');
  12  
  13  class TestTools extends lmbAbstractTools
  14  {
  15    var $foo_counter = 0;
  16  
  17    function foo()
  18    {
  19      $this->foo_counter++;
  20      return 'a';
  21    }
  22  
  23    function getFooCounter()
  24    {
  25      return $this->foo_counter;
  26    }
  27  
  28    function bar($arg)
  29    {
  30      return $arg;
  31    }
  32  
  33    function getVar()
  34    {
  35      return $this->_getRaw('var'); // this way we can prevent recursion

  36    }
  37  
  38    function setVar($value)
  39    {
  40      $this->_setRaw('var', $value); // this way we can prevent recursion

  41    }
  42  }
  43  
  44  class TestExtendingTools implements lmbToolkitTools
  45  {
  46    function getToolsSignatures()
  47    {
  48      return array('baz' => $this);
  49    }
  50  
  51    function baz()
  52    {
  53      return 'c';
  54    }
  55  }
  56  
  57  class TestIntersectingTools implements lmbToolkitTools
  58  {
  59    function getToolsSignatures()
  60    {
  61      return array('baz' => $this, 'foo' => $this);
  62    }
  63  
  64    function baz()
  65    {
  66      return 'c';
  67    }
  68  
  69    function foo()
  70    {
  71      return 'd';
  72    }
  73  }
  74  
  75  class lmbToolkitTest extends UnitTestCase
  76  {
  77    function setUp()
  78    {
  79      lmbToolkit :: save();
  80    }
  81  
  82    function tearDown()
  83    {
  84      lmbToolkit :: restore();
  85    }
  86  
  87    function testInstance()
  88    {
  89      return;
  90      $this->assertReference(lmbToolkit :: instance(),
  91                             lmbToolkit :: instance());
  92    }
  93  
  94    function testNoSuchMethod()
  95    {
  96      $toolkit = lmbToolkit :: setup(new TestTools());
  97  
  98      try
  99      {
 100        $toolkit->noSuchMethod();
 101        $this->assertTrue(false);
 102      }
 103      catch(lmbException $e){}
 104    }
 105  
 106    function testUseTools()
 107    {
 108      $toolkit = lmbToolkit :: setup(new TestTools());
 109      $this->assertEqual($toolkit->foo(), 'a');
 110      $this->assertEqual($toolkit->bar('b'), 'b');
 111    }
 112  
 113    function testSaveRestoreToolkit()
 114    {
 115      $toolkit = lmbToolkit :: setup(new TestTools());
 116      $toolkit->foo();
 117      $toolkit->foo();
 118      $this->assertEqual($toolkit->getFooCounter(), 2);
 119  
 120      $toolkit = lmbToolkit :: save();
 121      $toolkit->foo();
 122      $this->assertEqual($toolkit->getFooCounter(), 1);
 123      $toolkit = lmbToolkit :: restore();
 124  
 125      $toolkit->foo();
 126      $this->assertEqual($toolkit->getFooCounter(), 3);
 127  
 128      $toolkit = lmbToolkit :: save();
 129      $toolkit->foo();
 130      $this->assertEqual($toolkit->getFooCounter(), 1);
 131      $toolkit = lmbToolkit :: restore();
 132    }
 133  
 134    function testSaveAndRestoreAlwaysReturnTheSameToolkitInstance()
 135    {
 136      $toolkit = lmbToolkit :: setup(new TestTools());
 137      $toolkit1 = lmbToolkit :: save();
 138      $toolkit1->foo();
 139      $toolkit2 = lmbToolkit :: restore();
 140      $this->assertReference($toolkit1, $toolkit2);
 141      $toolkit3 = lmbToolkit :: save();
 142      $this->assertReference($toolkit1, $toolkit3);
 143    }
 144  
 145    function testExtendToolkit()
 146    {
 147      $toolkit = lmbToolkit :: setup(new TestTools());
 148      $toolkit->foo();
 149      $toolkit->foo();
 150      $this->assertEqual($toolkit->getFooCounter(), 2);
 151  
 152      try
 153      {
 154        $toolkit->baz();
 155        $this->assertTrue(false);
 156      }
 157      catch(lmbException $e){}
 158  
 159      $toolkit = lmbToolkit :: extend(new TestExtendingTools());
 160      $this->assertEqual($toolkit->baz(), 'c');
 161  
 162      $toolkit->foo();
 163      $this->assertEqual($toolkit->getFooCounter(), 1);
 164    }
 165  
 166    function testExtendPreserveCleanCopy()
 167    {
 168      lmbToolkit :: setup(new TestTools());
 169      $toolkit = lmbToolkit :: instance();
 170      $toolkit->foo();
 171      $toolkit->foo();
 172      $this->assertEqual($toolkit->getFooCounter(), 2);
 173  
 174      lmbToolkit :: extend(new TestExtendingTools());
 175      $toolkit = lmbToolkit :: instance();
 176      $this->assertEqual($toolkit->getFooCounter(), 0);
 177  
 178      lmbToolkit :: save();
 179      $toolkit = lmbToolkit :: instance();
 180      $toolkit->foo();
 181      $this->assertEqual($toolkit->getFooCounter(), 1);
 182      lmbToolkit :: restore();
 183  
 184      $toolkit = lmbToolkit :: instance();
 185      $this->assertEqual($toolkit->getFooCounter(), 0);
 186    }
 187  
 188    function testIntersectingToolkit()
 189    {
 190      lmbToolkit :: setup(new TestTools());
 191      $toolkit = lmbToolkit :: extend(new TestIntersectingTools());
 192  
 193      try
 194      {
 195        $toolkit->foo(); //we must call this method due to lazy loading of signatures

 196        $this->assertTrue(false);
 197      }
 198      catch(lmbException $e){}
 199    }
 200  
 201    function testSubstitute()
 202    {
 203      lmbToolkit :: setup(new TestTools());
 204      $toolkit = lmbToolkit :: merge(new TestIntersectingTools());
 205      $this->assertEqual($toolkit->foo(), 'd');
 206    }
 207  
 208    function testSubstitutePreserveCleanCopy()
 209    {
 210      lmbToolkit :: setup(new TestTools());
 211      $toolkit = lmbToolkit :: instance();
 212      $toolkit->foo();
 213      $toolkit->foo();
 214      $this->assertEqual($toolkit->getFooCounter(), 2);
 215  
 216      lmbToolkit :: merge(new TestTools());
 217      $toolkit = lmbToolkit :: instance();
 218      $this->assertEqual($toolkit->getFooCounter(), 0);
 219  
 220      lmbToolkit :: save();
 221      $toolkit = lmbToolkit :: instance();
 222      $toolkit->foo();
 223      $this->assertEqual($toolkit->getFooCounter(), 1);
 224      lmbToolkit :: restore();
 225  
 226      $toolkit = lmbToolkit :: instance();
 227      $this->assertEqual($toolkit->getFooCounter(), 0);
 228    }
 229  
 230    function testSetGet()
 231    {
 232      $toolkit = lmbToolkit :: instance();
 233      $toolkit->set('my_var', 'value1');
 234  
 235      $this->assertEqual($toolkit->get('my_var'), 'value1');
 236    }
 237  
 238    function testSaveAndRestoreProperties()
 239    {
 240      $toolkit = lmbToolkit :: instance();
 241      $toolkit->set('my_var', 'value1');
 242  
 243      lmbToolkit :: save();
 244  
 245      $toolkit->set('my_var', 'value2');
 246  
 247      lmbToolkit :: restore();
 248  
 249      $this->assertEqual($toolkit->get('my_var'), 'value1');
 250    }
 251  
 252    function testOverloadGetterByTools()
 253    {
 254      $toolkit = lmbToolkit :: setup(new TestTools());
 255      $toolkit->set('var', 'value1');
 256  
 257      $this->assertEqual($toolkit->getVar(), 'value1');
 258  
 259      lmbToolkit :: save();
 260  
 261      $toolkit->setVar('value2');
 262      $this->assertEqual($toolkit->getVar(), 'value2');
 263  
 264      lmbToolkit :: restore();
 265  
 266      $this->assertEqual($toolkit->get('var'), 'value1');
 267    }
 268  }
 269  
 270  ?>