Show
Ignore:
Timestamp:
09/17/08 14:11:31 (3 months ago)
Author:
tony
Message:

Refs #683: Added support for PHP 5.3 namespaces

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk

    • Property svn:ignore set to
      .project
      .cache
      .settings

  • trunk/generator/test/classes/propel/CharacterEncodingTest.php

    r1068 r1082  
    11<?php 
     2 
     3use bookstore::Peer as PropelPeer; 
     4use bookstore::Model as PropelModel; 
     5 
    26/* 
    37 *  $Id: GeneratedPeerTest.php 842 2007-12-02 16:28:20Z heltem $ 
    …… 
    5458        public function testUtf8() 
    5559        { 
    56                 $db = Propel::getDB(BookPeer::DATABASE_NAME); 
     60                $db = ::Propel::getDB(PropelPeer::BookPeer::DATABASE_NAME); 
    5761 
    5862                $title = "СЌерть Ма бруЎершафт. МлаЎеМец О черт"; 
    …… 
    6064                //                 1         2         3 
    6165 
    62                 $a = new Author(); 
     66                $a = new PropelModel::Author(); 
    6367                $a->setFirstName("Б."); 
    6468                $a->setLastName("АКУНИН"); 
    6569 
    66                 $p = new Publisher(); 
     70                $p = new PropelModel::Publisher(); 
    6771                $p->setName("ДетектОв рПссОйскОй, ПстрПсюжетМая прПза"); 
    6872 
    69                 $b = new Book(); 
     73                $b = new PropelModel::Book(); 
    7074                $b->setTitle($title); 
    7175                $b->setISBN("B-59246"); 
    …… 
    8387        public function testInvalidCharset() 
    8488        { 
    85                 $db = Propel::getDB(BookPeer::DATABASE_NAME); 
     89                $db = ::Propel::getDB(PropelPeer::BookPeer::DATABASE_NAME); 
    8690                if ($db instanceof DBSQLite) { 
    8791                        $this->markTestSkipped(); 
    8892                } 
    8993 
    90                 $a = new Author(); 
     94                $a = new PropelModel::Author(); 
    9195                $a->setFirstName("Б."); 
    9296                $a->setLastName("АКУНИН"); 
    …… 
    110114                        $a->save(); 
    111115                        $a->reload(); 
    112  
     116                        print_r($a); 
    113117                        $this->assertEquals("",$a->getLastName(), "Expected last_name to be empty (after inserting invalid charset data)"); 
    114118                } 
    …… 
    117121 
    118122} 
     123 
     124?> 

  • trunk/generator/test/classes/propel/FieldnameRelatedTest.php

    r1024 r1082  
    11<?php 
     2 
     3use bookstore::Peer as PropelPeer; 
     4use bookstore::Model as PropelModel; 
     5 
    26/* 
    37 *  $Id$ 
    …… 
    2832 * - Base[Object]Peer::getFieldNames() 
    2933 * - Base[Object]Peer::translateFieldName() 
    30  * - BasePeer::getFieldNames() 
    31  * - BasePeer::translateFieldName() 
     34 * - ::BasePeer::getFieldNames() 
     35 * - ::BasePeer::translateFieldName() 
    3236 * - Base[Object]::getByName() 
    3337 * - Base[Object]::setByName() 
    …… 
    4852        public function testFieldNameTypeConstants () { 
    4953 
    50                 $result = defined('BasePeer::TYPE_PHPNAME'); 
     54                $result = defined('::BasePeer::TYPE_PHPNAME'); 
    5155                $this->assertTrue($result); 
    5256        } 
    …… 
    5862 
    5963                $types = array( 
    60                         BasePeer::TYPE_PHPNAME, 
    61                         BasePeer::TYPE_COLNAME, 
    62                         BasePeer::TYPE_FIELDNAME, 
    63                         BasePeer::TYPE_NUM 
    64                 ); 
    65                 $expecteds = array ( 
    66                         BasePeer::TYPE_PHPNAME => array( 
     64                        ::BasePeer::TYPE_PHPNAME, 
     65                        ::BasePeer::TYPE_COLNAME, 
     66                        ::BasePeer::TYPE_FIELDNAME, 
     67                        ::BasePeer::TYPE_NUM 
     68                ); 
     69                $expecteds = array ( 
     70                        ::BasePeer::TYPE_PHPNAME => array( 
    6771                                0 => 'Id', 
    6872                                1 => 'Title', 
    …… 
    7276                                5 => 'AuthorId' 
    7377                        ), 
    74                         BasePeer::TYPE_STUDLYPHPNAME => array( 
     78                        ::BasePeer::TYPE_STUDLYPHPNAME => array( 
    7579                                0 => 'id', 
    7680                                1 => 'title', 
    …… 
    8084                                5 => 'authorId' 
    8185                        ), 
    82                         BasePeer::TYPE_COLNAME => array( 
     86                        ::BasePeer::TYPE_COLNAME => array( 
    8387                                0 => 'book.ID', 
    8488                                1 => 'book.TITLE', 
    …… 
    8892                                5 => 'book.AUTHOR_ID' 
    8993                        ), 
    90                         BasePeer::TYPE_FIELDNAME => array( 
     94                        ::BasePeer::TYPE_FIELDNAME => array( 
    9195                                0 => 'id', 
    9296                                1 => 'title', 
    …… 
    96100                                5 => 'author_id' 
    97101                        ), 
    98                         BasePeer::TYPE_NUM => array( 
     102                        ::BasePeer::TYPE_NUM => array( 
    99103                                0 => 0, 
    100104                                1 => 1, 
    …… 
    107111 
    108112                foreach ($types as $type) { 
    109                         $results[$type] = BookPeer::getFieldnames($type); 
     113                        $results[$type] = PropelPeer::BookPeer::getFieldnames($type); 
    110114                        $this->assertEquals( 
    111115                                $expecteds[$type], 
    …… 
    123127 
    124128                $types = array( 
    125                         BasePeer::TYPE_PHPNAME, 
    126                         BasePeer::TYPE_STUDLYPHPNAME, 
    127                         BasePeer::TYPE_COLNAME, 
    128                         BasePeer::TYPE_FIELDNAME, 
    129                         BasePeer::TYPE_NUM 
    130                 ); 
    131                 $expecteds = array ( 
    132                         BasePeer::TYPE_PHPNAME => 'AuthorId', 
    133                         BasePeer::TYPE_STUDLYPHPNAME => 'authorId', 
    134                         BasePeer::TYPE_COLNAME => 'book.AUTHOR_ID', 
    135                         BasePeer::TYPE_FIELDNAME => 'author_id', 
    136                         BasePeer::TYPE_NUM => 5, 
     129                        ::BasePeer::TYPE_PHPNAME, 
     130                        ::BasePeer::TYPE_STUDLYPHPNAME, 
     131                        ::BasePeer::TYPE_COLNAME, 
     132                        ::BasePeer::TYPE_FIELDNAME, 
     133                        ::BasePeer::TYPE_NUM 
     134                ); 
     135                $expecteds = array ( 
     136                        ::BasePeer::TYPE_PHPNAME => 'AuthorId', 
     137                        ::BasePeer::TYPE_STUDLYPHPNAME => 'authorId', 
     138                        ::BasePeer::TYPE_COLNAME => 'book.AUTHOR_ID', 
     139                        ::BasePeer::TYPE_FIELDNAME => 'author_id', 
     140                        ::BasePeer::TYPE_NUM => 5, 
    137141                ); 
    138142                foreach ($types as $fromType) { 
    …… 
    140144                                $name = $expecteds[$fromType]; 
    141145                                $expected = $expecteds[$toType]; 
    142                                 $result = BookPeer::translateFieldName($name, $fromType, $toType); 
     146                                $result = PropelPeer::BookPeer::translateFieldName($name, $fromType, $toType); 
    143147                                $this->assertEquals($expected, $result); 
    144148                        } 
    …… 
    147151 
    148152        /** 
    149          * Tests the BasePeer::getFieldNames() method 
     153         * Tests the ::BasePeer::getFieldNames() method 
    150154         */ 
    151155        public function testGetFieldNamesStatic () { 
    152156 
    153157                $types = array( 
    154                         BasePeer::TYPE_PHPNAME, 
    155                         BasePeer::TYPE_STUDLYPHPNAME, 
    156                         BasePeer::TYPE_COLNAME, 
    157                         BasePeer::TYPE_FIELDNAME, 
    158                         BasePeer::TYPE_NUM 
    159                 ); 
    160                 $expecteds = array ( 
    161                         BasePeer::TYPE_PHPNAME => array( 
     158                        ::BasePeer::TYPE_PHPNAME, 
     159                        ::BasePeer::TYPE_STUDLYPHPNAME, 
     160                        ::BasePeer::TYPE_COLNAME, 
     161                        ::BasePeer::TYPE_FIELDNAME, 
     162                        ::BasePeer::TYPE_NUM 
     163                ); 
     164                $expecteds = array ( 
     165                        ::BasePeer::TYPE_PHPNAME => array( 
    162166                                0 => 'Id', 
    163167                                1 => 'Title', 
    …… 
    167171                                5 => 'AuthorId' 
    168172                        ), 
    169                         BasePeer::TYPE_STUDLYPHPNAME => array( 
     173                        ::BasePeer::TYPE_STUDLYPHPNAME => array( 
    170174                                0 => 'id', 
    171175                                1 => 'title', 
    …… 
    175179                                5 => 'authorId' 
    176180                        ), 
    177                         BasePeer::TYPE_COLNAME => array( 
     181                        ::BasePeer::TYPE_COLNAME => array( 
    178182                                0 => 'book.ID', 
    179183                                1 => 'book.TITLE', 
    …… 
    183187                                5 => 'book.AUTHOR_ID' 
    184188                        ), 
    185                         BasePeer::TYPE_FIELDNAME => array( 
     189                        ::BasePeer::TYPE_FIELDNAME => array( 
    186190                                0 => 'id', 
    187191                                1 => 'title', 
    …… 
    191195                                5 => 'author_id' 
    192196                        ), 
    193                         BasePeer::TYPE_NUM => array( 
     197                        ::BasePeer::TYPE_NUM => array( 
    194198                                0 => 0, 
    195199                                1 => 1, 
    …… 
    202206 
    203207                foreach ($types as $type) { 
    204                         $results[$type] = BasePeer::getFieldnames('Book', $type); 
     208                        $results[$type] = ::BasePeer::getFieldnames('Book', $type); 
    205209                        $this->assertEquals( 
    206210                                $expecteds[$type], 
    …… 
    213217 
    214218        /** 
    215          * Tests the BasePeer::translateFieldName() method 
     219         * Tests the ::BasePeer::translateFieldName() method 
    216220         */ 
    217221        public function testTranslateFieldNameStatic () { 
    218222 
    219223                $types = array( 
    220                         BasePeer::TYPE_PHPNAME, 
    221                         BasePeer::TYPE_STUDLYPHPNAME, 
    222                         BasePeer::TYPE_COLNAME, 
    223                         BasePeer::TYPE_FIELDNAME, 
    224                         BasePeer::TYPE_NUM 
    225                 ); 
    226                 $expecteds = array ( 
    227                         BasePeer::TYPE_PHPNAME => 'AuthorId', 
    228                         BasePeer::TYPE_STUDLYPHPNAME => 'authorId', 
    229                         BasePeer::TYPE_COLNAME => 'book.AUTHOR_ID', 
    230                         BasePeer::TYPE_FIELDNAME => 'author_id', 
    231                         BasePeer::TYPE_NUM => 5, 
     224                        ::BasePeer::TYPE_PHPNAME, 
     225                        ::BasePeer::TYPE_STUDLYPHPNAME, 
     226                        ::BasePeer::TYPE_COLNAME, 
     227                        ::BasePeer::TYPE_FIELDNAME, 
     228                        ::BasePeer::TYPE_NUM 
     229                ); 
     230                $expecteds = array ( 
     231                        ::BasePeer::TYPE_PHPNAME => 'AuthorId', 
     232                        ::BasePeer::TYPE_STUDLYPHPNAME => 'authorId', 
     233                        ::BasePeer::TYPE_COLNAME => 'book.AUTHOR_ID', 
     234                        ::BasePeer::TYPE_FIELDNAME => 'author_id', 
     235                        ::BasePeer::TYPE_NUM => 5, 
    232236                ); 
    233237                foreach ($types as $fromType) { 
    …… 
    235239                                $name = $expecteds[$fromType]; 
    236240                                $expected = $expecteds[$toType]; 
    237                                 $result = BasePeer::translateFieldName('Book', $name, $fromType, $toType); 
     241                                $result = ::BasePeer::translateFieldName('Book', $name, $fromType, $toType); 
    238242                                $this->assertEquals($expected, $result); 
    239243                        } 
    …… 
    247251 
    248252                $types = array( 
    249                         BasePeer::TYPE_PHPNAME => 'Title', 
    250                         BasePeer::TYPE_STUDLYPHPNAME => 'title', 
    251                         BasePeer::TYPE_COLNAME => 'book.TITLE', 
    252                         BasePeer::TYPE_FIELDNAME => 'title', 
    253                         BasePeer::TYPE_NUM => 1 
    254                 ); 
    255  
    256                 $book = new Book(); 
     253                        ::BasePeer::TYPE_PHPNAME => 'Title', 
     254                        ::BasePeer::TYPE_STUDLYPHPNAME => 'title', 
     255                        ::BasePeer::TYPE_COLNAME => 'book.TITLE', 
     256                        ::BasePeer::TYPE_FIELDNAME => 'title', 
     257                        ::BasePeer::TYPE_NUM => 1 
     258                ); 
     259 
     260                $book = new PropelModel::Book(); 
    257261                $book->setTitle('Harry Potter and the Order of the Phoenix'); 
    258262 
    …… 
    269273        public function testSetByName() { 
    270274 
    271                 $book = new Book(); 
    272                 $types = array( 
    273                         BasePeer::TYPE_PHPNAME => 'Title', 
    274                         BasePeer::TYPE_STUDLYPHPNAME => 'title', 
    275                         BasePeer::TYPE_COLNAME => 'book.TITLE', 
    276                         BasePeer::TYPE_FIELDNAME => 'title', 
    277                         BasePeer::TYPE_NUM => 1 
     275                $book = new PropelModel::Book(); 
     276                $types = array( 
     277                        ::BasePeer::TYPE_PHPNAME => 'Title', 
     278                        ::BasePeer::TYPE_STUDLYPHPNAME => 'title', 
     279                        ::BasePeer::TYPE_COLNAME => 'book.TITLE', 
     280                        ::BasePeer::TYPE_FIELDNAME => 'title', 
     281                        ::BasePeer::TYPE_NUM => 1 
    278282                ); 
    279283 
    …… 
    294298 
    295299                $types = array( 
    296                         BasePeer::TYPE_PHPNAME, 
    297                         BasePeer::TYPE_STUDLYPHPNAME, 
    298                         BasePeer::TYPE_COLNAME, 
    299                         BasePeer::TYPE_FIELDNAME, 
    300                         BasePeer::TYPE_NUM 
    301                 ); 
    302                 $expecteds = array ( 
    303                         BasePeer::TYPE_PHPNAME => array ( 
     300                        ::BasePeer::TYPE_PHPNAME, 
     301                        ::BasePeer::TYPE_STUDLYPHPNAME, 
     302                        ::BasePeer::TYPE_COLNAME, 
     303                        ::BasePeer::TYPE_FIELDNAME, 
     304                        ::BasePeer::TYPE_NUM 
     305                ); 
     306                $expecteds = array ( 
     307                        ::BasePeer::TYPE_PHPNAME => array ( 
    304308                                'Title' => 'Harry Potter and the Order of the Phoenix', 
    305309                                'ISBN' => '043935806X' 
    306310                        ), 
    307                         BasePeer::TYPE_STUDLYPHPNAME => array ( 
     311                        ::BasePeer::TYPE_STUDLYPHPNAME => array ( 
    308312                                'title' => 'Harry Potter and the Order of the Phoenix', 
    309313                                'iSBN' => '043935806X' 
    310314                        ), 
    311                         BasePeer::TYPE_COLNAME => array ( 
     315                        ::BasePeer::TYPE_COLNAME => array ( 
    312316                                'book.TITLE' => 'Harry Potter and the Order of the Phoenix', 
    313317                                'book.ISBN' => '043935806X' 
    314318                        ), 
    315                         BasePeer::TYPE_FIELDNAME => array ( 
     319                        ::BasePeer::TYPE_FIELDNAME => array ( 
    316320                                'title' => 'Harry Potter and the Order of the Phoenix', 
    317321                                'isbn' => '043935806X' 
    318322                        ), 
    319                         BasePeer::TYPE_NUM => array ( 
     323                        ::BasePeer::TYPE_NUM => array ( 
    320324                                '1' => 'Harry Potter and the Order of the Phoenix', 
    321325                                '2' => '043935806X' 
    …… 
    323327                ); 
    324328 
    325                 $book = new Book(); 
     329                $book = new PropelModel::Book(); 
    326330 
    327331                foreach ($types as $type) { 
    …… 
    347351 
    348352                $types = array( 
    349                         BasePeer::TYPE_PHPNAME, 
    350                         BasePeer::TYPE_STUDLYPHPNAME, 
    351                         BasePeer::TYPE_COLNAME, 
    352                         BasePeer::TYPE_FIELDNAME, 
    353                         BasePeer::TYPE_NUM 
    354                 ); 
    355  
    356                 $book = new Book(); 
     353                        ::BasePeer::TYPE_PHPNAME, 
     354                        ::BasePeer::TYPE_STUDLYPHPNAME, 
     355                        ::BasePeer::TYPE_COLNAME, 
     356                        ::BasePeer::TYPE_FIELDNAME, 
     357                        ::BasePeer::TYPE_NUM 
     358                ); 
     359 
     360                $book = new PropelModel::Book(); 
    357361                $book->fromArray(array ( 
    358362                        'Title' => 'Harry Potter and the Order of the Phoenix', 
    …… 
    361365 
    362366                $expecteds = array ( 
    363                         BasePeer::TYPE_PHPNAME => array ( 
     367                        ::BasePeer::TYPE_PHPNAME => array ( 
    364368                                'Title' => 'Harry Potter and the Order of the Phoenix', 
    365369                                'ISBN' => '043935806X' 
    366370                        ), 
    367                         BasePeer::TYPE_STUDLYPHPNAME => array ( 
     371                        ::BasePeer::TYPE_STUDLYPHPNAME => array ( 
    368372                                'title' => 'Harry Potter and the Order of the Phoenix', 
    369373                                'iSBN' => '043935806X' 
    370374                        ), 
    371                         BasePeer::TYPE_COLNAME => array ( 
     375                        ::BasePeer::TYPE_COLNAME => array ( 
    372376                                'book.TITLE' => 'Harry Potter and the Order of the Phoenix', 
    373377                                'book.ISBN' => '043935806X' 
    374378                        ), 
    375                         BasePeer::TYPE_FIELDNAME => array ( 
     379                        ::BasePeer::TYPE_FIELDNAME => array ( 
    376380                                'title' => 'Harry Potter and the Order of the Phoenix', 
    377381                                'isbn' => '043935806X' 
    378382                        ), 
    379                         BasePeer::TYPE_NUM => array ( 
     383                        ::BasePeer::TYPE_NUM => array ( 
    380384                                '1' => 'Harry Potter and the Order of the Phoenix', 
    381385                                '2' => '043935806X' 
    …… 
    397401        } 
    398402} 
     403 
     404?> 

  • trunk/generator/test/classes/propel/GeneratedNestedSetObjectTest.php

    r1068 r1082  
    11<?php 
     2 
     3use bookstore::Peer as PropelPeer; 
     4use bookstore::Model as PropelModel; 
     5 
    26/* 
    37 *  $Id: GeneratedNestedSetObjectTest.php 894 2007-12-27 14:39:01Z heltem $ 
    …… 
    4347        public function testObjectIsRootTrue() 
    4448        { 
    45                 $pp = PagePeer::retrieveRoot(1); 
     49                $pp = PropelPeer::PagePeer::retrieveRoot(1); 
    4650                $this->assertTrue($pp->isRoot(), 'Node must be root'); 
    4751        } 
    …… 
    5256        public function testObjectIsRootFalse() 
    5357        { 
    54                 $c = new Criteria(PagePeer::DATABASE_NAME); 
    55                 $c->add(PagePeer::TITLE, 'school', Criteria::EQUAL); 
     58                $c = new ::Criteria(PropelPeer::PagePeer::DATABASE_NAME); 
     59                $c->add(PropelPeer::PagePeer::TITLE, 'school', ::Criteria::EQUAL); 
    5660 
    57                 $school = PagePeer::doSelectOne($c); 
     61                $school = PropelPeer::PagePeer::doSelectOne($c); 
    5862                $this->assertFalse($school->isRoot(), 'Node must not be root'); 
    5963        } 
    …… 
    6468        public function testObjectRetrieveParentTrue() 
    6569        { 
    66                 $c = new Criteria(PagePeer::DATABASE_NAME); 
    67                 $c->add(PagePeer::TITLE, 'school', Criteria::EQUAL); 
     70                $c = new ::Criteria(PropelPeer::PagePeer::DATABASE_NAME); 
     71                $c->add(PropelPeer::PagePeer::TITLE, 'school', ::Criteria::EQUAL); 
    6872 
    69                 $school = PagePeer::doSelectOne($c); 
     73                $school = PropelPeer::PagePeer::doSelectOne($c); 
    7074                $this->assertNotNull($school->retrieveParent(), 'Parent node must exist'); 
    7175        } 
    …… 
    7680        public function testObjectRetrieveParentFalse() 
    7781        { 
    78                 $c = new Criteria(PagePeer::DATABASE_NAME); 
    79                 $c->add(PagePeer::TITLE, 'home', Criteria::EQUAL); 
     82                $c = new ::Criteria(PropelPeer::PagePeer::DATABASE_NAME); 
     83                $c->add(PropelPeer::PagePeer::TITLE, 'home', ::Criteria::EQUAL); 
    8084 
    81                 $home = PagePeer::doSelectOne($c); 
     85                $home = PropelPeer::PagePeer::doSelectOne($c); 
    8286                $this->assertNull($home->retrieveParent(), 'Parent node must not exist and retrieved not be null'); 
    8387        } 
    …… 
    8892        public function testObjectHasParentTrue() 
    8993        { 
    90                 $c = new Criteria(); 
    91                 $c->add(PagePeer::TITLE, 'school', Criteria::EQUAL); 
     94                $c = new ::Criteria(); 
     95                $c->add(PropelPeer::PagePeer::TITLE, 'school', ::Criteria::EQUAL); 
    9296 
    93                 $school = PagePeer::doSelectOne($c); 
     97                $school = PropelPeer::PagePeer::doSelectOne($c); 
    9498                $this->assertTrue($school->hasParent(), 'Node must have parent node'); 
    9599        } 
    …… 
    100104        public function testObjectHasParentFalse() 
    101105        { 
    102                 $c = new Criteria(); 
    103                 $c->add(PagePeer::TITLE, 'home', Criteria::EQUAL); 
     106                $c = new ::Criteria(); 
     107                $c->add(PropelPeer::PagePeer::TITLE, 'home', ::Criteria::EQUAL); 
    104108 
    105                 $home = PagePeer::doSelectOne($c); 
     109                $home = PropelPeer::PagePeer::doSelectOne($c); 
    106110                $this->assertFalse($home->hasParent(), 'Root node must not have parent'); 
    107111        } 
    …… 
    112116        public function testObjectIsLeafTrue() 
    113117        { 
    114                 $c = new Criteria(); 
    115                 $c->add(PagePeer::TITLE, 'simulator', Criteria::EQUAL); 
     118                $c = new ::Criteria(); 
     119                $c->add(PropelPeer::PagePeer::TITLE, 'simulator', ::Criteria::EQUAL); 
    116120 
    117                 $simulator = PagePeer::doSelectOne($c); 
     121                $simulator = PropelPeer::PagePeer::doSelectOne($c); 
    118122                $this->assertTrue($simulator->isLeaf($simulator), 'Node must be a leaf'); 
    119123        } 
    …… 
    124128        public function testObjectIsLeafFalse() 
    125129        { 
    126                 $c = new Criteria(); 
    127                 $c->add(PagePeer::TITLE, 'contact', Criteria::EQUAL); 
     130                $c = new ::Criteria(); 
     131                $c->add(PropelPeer::PagePeer::TITLE, 'contact', ::Criteria::EQUAL); 
    128132 
    129                 $contact = PagePeer::doSelectOne($c); 
     133                $contact = PropelPeer::PagePeer::doSelectOne($c); 
    130134                $this->assertFalse($contact->isLeaf($contact), 'Node must not be a leaf'); 
    131135        } 
    …… 
    136140        public function testObjectMakeRoot() 
    137141        { 
    138                 $page = new Page(); 
     142                $page = new PropelModel::Page(); 
    139143                $page->makeRoot(); 
    140144                $this->assertEquals(1, $page->getLeftValue(), 'Node left value must equal 1'); 
    …… 
    148152        public function testObjectMakeRootException() 
    149153        { 
    150                 $c = new Criteria(); 
    151                 $c->add(PagePeer::TITLE, 'home', Criteria::EQUAL); 
     154                $c = new ::Criteria(); 
     155                $c->add(PropelPeer::PagePeer::TITLE, 'home', ::Criteria::EQUAL); 
    152156 
    153                 $home = PagePeer::doSelectOne($c); 
     157                $home = PropelPeer::PagePeer::doSelectOne($c); 
    154158                $home->makeRoot(); 
    155159        } 
    156160 
    157161} 
     162 
     163?> 

  • trunk/generator/test/classes/propel/GeneratedNestedSetPeerTest.php

    r1068 r1082  
    11<?php 
     2 
     3use bookstore::Peer as PropelPeer; 
     4use bookstore::Model as PropelModel; 
     5 
    26/* 
    37 *  $Id: GeneratedNestedSetPeerTest.php 989 2008-03-11 14:29:30Z heltem $ 
    …… 
    4347        public function testRetrieveRootExist() 
    4448        { 
    45                 $pp = PagePeer::retrieveRoot(1); 
     49                $pp = PropelPeer::PagePeer::retrieveRoot(1); 
    4650                $this->assertNotNull($pp, 'Node must exist and not be null'); 
    4751                $this->assertEquals(1, $pp->getLeftValue(), 'Node left value must be equal to 1'); 
    …… 
    5357        public function testRetrieveRootNotExist() 
    5458        { 
    55                 $pp = PagePeer::retrieveRoot(2); 
     59                $pp = PropelPeer::PagePeer::retrieveRoot(2); 
    5660                $this->assertNull($pp, 'Root with such scopeId must not exist'); 
    5761        } 
    …… 
    6266        public function testPeerIsRootTrue() 
    6367        { 
    64                 $pp = PagePeer::retrieveRoot(1); 
    65                 $this->assertTrue(PagePeer::isRoot($pp), 'Node must be root'); 
     68                $pp = PropelPeer::PagePeer::retrieveRoot(1); 
     69                $this->assertTrue(PropelPeer::PagePeer::isRoot($pp), 'Node must be root'); 
    6670        } 
    6771 
    …… 
    7175        public function testPeerIsRootFalse() 
    7276        { 
    73                 $c = new Criteria(PagePeer::DATABASE_NAME); 
    74                 $c->add(PagePeer::TITLE, 'school', Criteria::EQUAL); 
    75  
    76                 $school = PagePeer::doSelectOne($c); 
    77                 $this->assertFalse(PagePeer::isRoot($school), 'Node must not be root'); 
     77                $c = new ::Criteria(PropelPeer::PagePeer::DATABASE_NAME); 
     78                $c->add(PropelPeer::PagePeer::TITLE, 'school', ::Criteria::EQUAL); 
     79 
     80                $school = PropelPeer::PagePeer::doSelectOne($c); 
     81                $this->assertFalse(PropelPeer::PagePeer::isRoot($school), 'Node must not be root'); 
    7882        } 
    7983 
    …… 
    8387        public function testPeerRetrieveParentTrue() 
    8488        { 
    85                 $c = new Criteria(PagePeer::DATABASE_NAME); 
    86                 $c->add(PagePeer::TITLE, 'school', Criteria::EQUAL); 
    87  
    88                 $school = PagePeer::doSelectOne($c); 
    89                 $this->assertNotNull(PagePeer::retrieveParent($school), 'Parent node must exist'); 
     89                $c = new ::Criteria(PropelPeer::PagePeer::DATABASE_NAME); 
     90                $c->add(PropelPeer::PagePeer::TITLE, 'school', ::Criteria::EQUAL); 
     91 
     92                $school = PropelPeer::PagePeer::doSelectOne($c); 
     93                $this->assertNotNull(PropelPeer::PagePeer::retrieveParent($school), 'Parent node must exist'); 
    9094        } 
    9195 
    …… 
    9599        public function testPeerRetrieveParentFalse() 
    96100        { 
    97                 $c = new Criteria(PagePeer::DATABASE_NAME); 
    98                 $c->add(PagePeer::TITLE, 'home', Criteria::EQUAL); 
    99  
    100                 $home = PagePeer::doSelectOne($c); 
    101                 $this->assertNull(PagePeer::retrieveParent($home), 'Parent node must not exist and retrieved not be null'); 
     101                $c = new ::Criteria(PropelPeer::PagePeer::DATABASE_NAME); 
     102                $c->add(PropelPeer::PagePeer::TITLE, 'home', ::Criteria::EQUAL); 
     103 
     104                $home = PropelPeer::PagePeer::doSelectOne($c); 
     105                $this->assertNull(PropelPeer::PagePeer::retrieveParent($home), 'Parent node must not exist and retrieved not be null'); 
    102106        } 
    103107 
    …… 
    107111        public function testPeerHasParentTrue() 
    108112        { 
    109                 $c = new Criteria(); 
    110                 $c->add(PagePeer::TITLE, 'school', Criteria::EQUAL); 
    111  
    112                 $school = PagePeer::doSelectOne($c); 
    113                 $this->assertTrue(PagePeer::hasParent($school), 'Node must have parent node'); 
     113                $c = new ::Criteria(); 
     114                $c->add(PropelPeer::PagePeer::TITLE, 'school', ::Criteria::EQUAL); 
     115 
     116                $school = PropelPeer::PagePeer::doSelectOne($c); 
     117                $this->assertTrue(PropelPeer::PagePeer::hasParent($school), 'Node must have parent node'); 
    114118        } 
    115119 
    …… 
    119123        public function testPeerHasParentFalse() 
    120124        { 
    121                 $c = new Criteria(); 
    122                 $c->add(PagePeer::TITLE, 'home', Criteria::EQUAL); 
    123  
    124                 $home = PagePeer::doSelectOne($c); 
    125                 $this->assertFalse(PagePeer::hasParent($home), 'Root node must not have parent'); 
     125                $c = new ::Criteria(); 
     126                $c->add(PropelPeer::PagePeer::TITLE, 'home', ::Criteria::EQUAL); 
     127 
     128                $home = PropelPeer::PagePeer::doSelectOne($c); 
     129                $this->assertFalse(PropelPeer::PagePeer::hasParent($home), 'Root node must not have parent'); 
    126130        } 
    127131 
    …… 
    131135        public function testPeerIsValidTrue() 
    132136        { 
    133                 $c = new Criteria(); 
    134                 $c->add(PagePeer::TITLE, 'school', Criteria::EQUAL); 
    135  
    136                 $school = PagePeer::doSelectOne($c); 
    137                 $this->assertTrue(PagePeer::isValid($school), 'Node must be valid'); 
     137                $c = new ::Criteria(); 
     138                $c->add(PropelPeer::PagePeer::TITLE, 'school', ::Criteria::EQUAL); 
     139 
     140                $school = PropelPeer::PagePeer::doSelectOne($c); 
     141                $this->assertTrue(PropelPeer::PagePeer::isValid($school), 'Node must be valid'); 
    138142        } 
    139143 
    …… 
    143147        public function testPeerIsValidFalse() 
    144148        { 
    145                 $page = new Page(); 
    146                 $this->assertFalse(PagePeer::isValid($page), 'Node left and right values must be invalid'); 
    147                 $this->assertFalse(PagePeer::isValid(null), 'Null must be invalid'); 
     149                $page = new PropelModel::Page(); 
     150                $this->assertFalse(PropelPeer::PagePeer::isValid($page), 'Node left and right values must be invalid'); 
     151                $this->assertFalse(PropelPeer::PagePeer::isValid(null), 'Null must be invalid'); 
    148152        } 
    149153 
    …… 
    153157        public function testPeerIsLeafTrue() 
    154158        { 
    155                 $c = new Criteria(); 
    156                 $c->add(PagePeer::TITLE, 'simulator', Criteria::EQUAL); 
    157  
    158                 $simulator = PagePeer::doSelectOne($c); 
    159                 $this->assertTrue(PagePeer::isLeaf($simulator), 'Node must be a leaf'); 
     159                $c = new ::Criteria(); 
     160                $c->add(PropelPeer::PagePeer::TITLE, 'simulator', ::Criteria::EQUAL); 
     161 
     162                $simulator = PropelPeer::PagePeer::doSelectOne($c); 
     163                $this->assertTrue(PropelPeer::PagePeer::isLeaf($simulator), 'Node must be a leaf'); 
    160164        } 
    161165 
    …… 
    165169        public function testPeerIsLeafFalse() 
    166170        { 
    167                 $c = new Criteria(); 
    168                 $c->add(PagePeer::TITLE, 'contact', Criteria::EQUAL); 
    169  
    170                 $contact = PagePeer::doSelectOne($c); 
    171                 $this->assertFalse(PagePeer::isLeaf($contact), 'Node must not be a leaf'); 
     171                $c = new ::Criteria(); 
     172                $c->add(PropelPeer::PagePeer::TITLE, 'contact', ::Criteria::EQUAL); 
     173 
     174                $contact = PropelPeer::PagePeer::doSelectOne($c); 
     175                $this->assertFalse(PropelPeer::PagePeer::isLeaf($contact), 'Node must not be a leaf'); 
    172176        } 
    173177 
    …… 
    177181        public function testPeerCreateRoot() 
    178182        { 
    179                 $page = new Page(); 
    180                 PagePeer::createRoot($page); 
     183                $page = new PropelModel::Page(); 
     184                PropelPeer::PagePeer::createRoot($page); 
    181185                $this->assertEquals(1, $page->getLeftValue(), 'Node left value must equal 1'); 
    182186                $this->assertEquals(2, $page->getRightValue(), 'Node right value must equal 2'); 
    …… 
    189193        public function testPeerCreateRootException() 
    190194        { 
    191                 $c = new Criteria(); 
    192                 $c->add(PagePeer::TITLE, 'home', Criteria::EQUAL); 
    193  
    194                 $home = PagePeer::doSelectOne($c); 
    195                 PagePeer::createRoot($home); 
     195                $c = new ::Criteria(); 
     196                $c->add(PropelPeer::PagePeer::TITLE, 'home', ::Criteria::EQUAL); 
     197 
     198                $home = PropelPeer::PagePeer::doSelectOne($c); 
     199                PropelPeer::PagePeer::createRoot($home); 
    196200        } 
    197201 
    198202} 
     203 
     204?> 

  • trunk/generator/test/classes/propel/GeneratedNestedSetTest.php

    r1068 r1082  
    11<?php