<?php
/**
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
 * @version //autogentag//
 * @filesource
 * @package PersistentObject
 * @subpackage Tests
 */

require_once dirname( __FILE__ ) . '/relation_prefetch_test.php';

/**
 * Tests ezcPersistentManyToOneRelation class.
 *
 * @package PersistentObject
 * @subpackage Tests
 */
class ezcPersistentSessionIdentityDecoratorRelationObjectExtractorTest extends ezcPersistentSessionIdentityDecoratorRelationPrefetchTest
{
    protected $sesstion;

    protected $idMap;

    protected $extractor;

    protected $options;

    public static function suite()
    {
        return new PHPUnit_Framework_TestSuite( __CLASS__ );
    }

    public function setup()
    {
        parent::setup();

        RelationTestPerson::setupTables( $this->db );
        RelationTestPerson::insertData( $this->db );

        $this->session = new ezcPersistentSession(
            $this->db,
            $this->defManager
        );

        $this->idMap = new ezcPersistentBasicIdentityMap(
            $this->defManager
        );

        $this->options   =  new ezcPersistentSessionIdentityDecoratorOptions();
        $this->extractor = new ezcPersistentIdentityRelationObjectExtractor(
            $this->idMap,
            $this->defManager,
            $this->options
        );
    }

    public function teardown()
    {
        RelationTestEmployer::cleanup( $this->db );
    }

    public function testLoadOneLevelOneRelation()
    {
        $relations = $this->getOneLevelOneRelationRelations();
        $q         = $this->getLoadQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        // Actual test
        $this->extractor->extractObjectWithRelatedObjects(
            $stmt, 'RelationTestPerson', 2, $relations
        );

        $person = $this->idMap->getIdentity( 'RelationTestPerson', 2 );
        $this->assertNotNull( $person );
        $this->assertEquals(
            $this->session->load( 'RelationTestPerson', 2 ),
            $person
        );

        $employers = $this->idMap->getRelatedObjects(
            $person, 'RelationTestEmployer'
        );
        
        $this->assertNotNull( $employers );

        $this->assertEquals( 1, count( $employers ) );

        $this->assertEquals(
            current( $employers ),
            current( $this->session->getRelatedObjects( $person, 'RelationTestEmployer' ) )
        );
    }

    public function testFindOneLevelOneRelationNoRestrictions()
    {
        $relations = $this->getOneLevelOneRelationRelations();
        $q         = $this->getFindQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();


        // Actual test
        $persons = $this->extractor->extractObjectsWithRelatedObjects(
            $stmt, $q
        );

        $fakeFind = $this->session->createFindQuery( 'RelationTestPerson' );
        $fakeRes = $this->session->find( $fakeFind );

        $this->assertEquals(
            $fakeRes,
            $persons,
            'Returned extracted object set incorrect.'
        );

        foreach ( $persons as $person )
        {
            $this->assertEquals(
                $this->session->getRelatedObjects( $person, 'RelationTestEmployer' ),
                $this->idMap->getRelatedObjects( $person, 'RelationTestEmployer' )
            );
        }
    }

    public function testFindOneLevelOneRelationRestrictions()
    {
        $relations = $this->getOneLevelOneRelationRelations();
        $q         = $this->getFindQuery( $relations );
        $q->where(
            $q->expr->like(
                $this->qi( 'employer' ) . '.' . $this->qi( 'name' ),
                $q->bindValue( '%Web%' )
            )
        );
        
        $stmt = $q->prepare();
        $stmt->execute();


        // Actual test
        $persons = $this->extractor->extractObjectsWithRelatedObjects(
            $stmt, $q
        );

        $fakeFind = $this->session->createFindQuery( 'RelationTestPerson' );
        $fakeRes = $this->session->find( $fakeFind );

        $this->assertEquals(
            $fakeRes,
            $persons,
            'Returned extracted object set incorrect.'
        );

        foreach ( $persons as $person )
        {
            $this->assertNull(
                $this->idMap->getRelatedObjects( $person, 'RelationTestEmployer' )
            );
            $this->assertNotNull(
                $this->idMap->getRelatedObjectSet( $person, 'employer' )
            );
        }
    }

    public function testNamedSetNotOverwritten()
    {
        // Create fake named related set
        $person = $this->session->load( 'RelationTestPerson', 2 );
        $this->idMap->setIdentity( $person );

        $birthday = new RelationTestBirthday();
        $birthday->person = 2;
        $relatedObjectSet = array(
            '2' => $birthday
        );

        $this->idMap->setRelatedObjectSet(
            $person, $relatedObjectSet, 'foo'
        );

        // Perform query and extraction
        $relations = $this->getOneLevelOneRelationRelations();
        $q         = $this->getLoadQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        $this->extractor->extractObjectWithRelatedObjects(
            $stmt, 'RelationTestPerson', 2, $relations
        );

        $this->assertSame(
            $person,
            $this->idMap->getIdentity( 'RelationTestPerson', 2 )
        );

        $employers = $this->idMap->getRelatedObjects(
            $person, 'RelationTestEmployer'
        );
        
        $this->assertNotNull( $employers );

        $this->assertEquals( 1, count( $employers ) );

        $this->assertEquals(
            current( $employers ),
            current( $this->session->getRelatedObjects( $person, 'RelationTestEmployer' ) )
        );

        
        $this->assertEquals(
            $relatedObjectSet,
            $this->idMap->getRelatedObjectSet( $person, 'foo' )    
        );
    }

    public function testNoRefetch()
    {
        $relations = $this->getOneLevelOneRelationRelations();
        $q         = $this->getLoadQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        $this->extractor->extractObjectWithRelatedObjects(
            $stmt, 'RelationTestPerson', 2, $relations
        );

        $person = $this->idMap->getIdentity( 'RelationTestPerson', 2 );
        $this->assertNotNull( $person );
        $this->assertEquals(
            $this->session->load( 'RelationTestPerson', 2 ),
            $person
        );

        $employers = $this->idMap->getRelatedObjects(
            $person, 'RelationTestEmployer'
        );
        
        $this->assertNotNull( $employers );

        $this->assertEquals( 1, count( $employers ) );

        $this->assertEquals(
            current( $employers ),
            current( $this->session->getRelatedObjects( $person, 'RelationTestEmployer' ) )
        );

        // $this->options->refetch = true;

        $relations = $this->getOneLevelOneRelationRelations();
        $q         = $this->getLoadQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        $this->extractor->extractObjectWithRelatedObjects(
            $stmt, 'RelationTestPerson', 2, $relations
        );

        $secPerson = $this->idMap->getIdentity( 'RelationTestPerson', 2 );
        $this->assertNotNull( $secPerson );
        $this->assertEquals(
            $this->session->load( 'RelationTestPerson', 2 ),
            $secPerson
        );

        $this->assertSame( $person, $secPerson );

        $secEmployers = $this->idMap->getRelatedObjects(
            $secPerson, 'RelationTestEmployer'
        );
        
        $this->assertNotNull( $secEmployers );

        $this->assertEquals( 1, count( $secEmployers ) );

        $this->assertEquals(
            current( $secEmployers ),
            current( $this->session->getRelatedObjects( $secPerson, 'RelationTestEmployer' ) )
        );

        foreach ( $employers as $id => $employer )
        {
            $this->assertSame(
                $employer,
                $secEmployers[$id]
            );
        }
    }

    public function testRefetch()
    {
        $relations = $this->getOneLevelOneRelationRelations();
        $q         = $this->getLoadQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        $this->extractor->extractObjectWithRelatedObjects(
            $stmt, 'RelationTestPerson', 2, $relations
        );

        $person = $this->idMap->getIdentity( 'RelationTestPerson', 2 );
        $this->assertNotNull( $person );
        $this->assertEquals(
            $this->session->load( 'RelationTestPerson', 2 ),
            $person
        );

        $employers = $this->idMap->getRelatedObjects(
            $person, 'RelationTestEmployer'
        );
        
        $this->assertNotNull( $employers );

        $this->assertEquals( 1, count( $employers ) );

        $this->assertEquals(
            current( $employers ),
            current( $this->session->getRelatedObjects( $person, 'RelationTestEmployer' ) )
        );

        $this->options->refetch = true;

        $relations = $this->getOneLevelOneRelationRelations();
        $q         = $this->getLoadQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        $this->extractor->extractObjectWithRelatedObjects(
            $stmt, 'RelationTestPerson', 2, $relations
        );

        $secPerson = $this->idMap->getIdentity( 'RelationTestPerson', 2 );
        $this->assertNotNull( $secPerson );
        $this->assertEquals(
            $this->session->load( 'RelationTestPerson', 2 ),
            $secPerson
        );

        $this->assertNotSame( $person, $secPerson );

        $secEmployers = $this->idMap->getRelatedObjects(
            $secPerson, 'RelationTestEmployer'
        );
        
        $this->assertNotNull( $secEmployers );

        $this->assertEquals( 1, count( $secEmployers ) );

        $this->assertEquals(
            current( $secEmployers ),
            current( $this->session->getRelatedObjects( $secPerson, 'RelationTestEmployer' ) )
        );

        foreach ( $employers as $id => $employer )
        {
            $this->assertNotSame(
                $employer,
                $secEmployers[$id]
            );
        }
    }

    public function testLoadOneLevelMultiRelation()
    {
        $relations = $this->getOneLevelMultiRelationRelations();
        $q         = $this->getLoadQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        // Actual test
        $this->extractor->extractObjectWithRelatedObjects(
            $stmt, 'RelationTestPerson', 2, $relations
        );

        $person = $this->idMap->getIdentity( 'RelationTestPerson', 2 );
        $this->assertNotNull( $person );
        $this->assertEquals(
            $this->session->load( 'RelationTestPerson', 2 ),
            $person
        );

        $employers = $this->idMap->getRelatedObjects(
            $person, 'RelationTestEmployer'
        );
        
        $this->assertNotNull( $employers );

        $this->assertEquals( 1, count( $employers ) );

        $this->assertEquals(
            current( $employers ),
            current( $this->session->getRelatedObjects( $person, 'RelationTestEmployer' ) )
        );

        $addresses = $this->idMap->getRelatedObjects(
            $person, 'RelationTestAddress'
        );
        
        $this->assertNotNull( $addresses );

        $this->assertEquals( 3, count( $addresses ) );

        $this->assertEquals(
            current( $addresses ),
            current( $this->session->getRelatedObjects( $person, 'RelationTestAddress' ) )
        );
    }

    public function testFindOneLevelMultiRelationNoRestrictions()
    {
        $relations = $this->getOneLevelMultiRelationRelations();
        $q         = $this->getFindQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        // Actual test
        $persons = $this->extractor->extractObjectsWithRelatedObjects(
            $stmt, $q
        );

        $fakeFind = $this->session->createFindQuery( 'RelationTestPerson' );
        $fakeRes = $this->session->find( $fakeFind );

        $this->assertEquals(
            $fakeRes,
            $persons,
            'Returned extracted object set incorrect.'
        );

        foreach ( $persons as $person )
        {
            $this->assertEquals(
                $this->session->getRelatedObjects( $person, 'RelationTestEmployer' ),
                $this->idMap->getRelatedObjects( $person, 'RelationTestEmployer' )
            );
            $this->assertEquals(
                $this->session->getRelatedObjects( $person, 'RelationTestAddress' ),
                $this->idMap->getRelatedObjects( $person, 'RelationTestAddress' )
            );
        }
    }

    public function testFindOneLevelMultiRelationRestrictions()
    {
        $relations = $this->getOneLevelMultiRelationRelations();
        $q         = $this->getFindQuery( $relations );

        $q->where(
            $q->expr->like(
                $this->qi( 'employer' ) . '.' . $this->qi( 'name' ),
                $q->bindValue( '%Web%' )
            )
        );
        
        $stmt = $q->prepare();
        $stmt->execute();

        // Actual test
        $persons = $this->extractor->extractObjectsWithRelatedObjects(
            $stmt, $q
        );

        $fakeFind = $this->session->createFindQuery( 'RelationTestPerson' );
        $fakeRes = $this->session->find( $fakeFind );

        $this->assertEquals(
            $fakeRes,
            $persons,
            'Returned extracted object set incorrect.'
        );

        foreach ( $persons as $person )
        {
            $this->assertNull(
                $this->idMap->getRelatedObjects( $person, 'RelationTestEmployer' )
            );
            $this->assertNotNull(
                $this->idMap->getRelatedObjectSet( $person, 'employer' )
            );
            $this->assertNull(
                $this->idMap->getRelatedObjects( $person, 'RelationTestAddress' )
            );
            $this->assertEquals(
                $this->session->getRelatedObjects( $person, 'RelationTestAddress' ),
                $this->idMap->getRelatedObjectSet( $person, 'address' )
            );
        }
    }

    public function testLoadMultiLevelSingleRelation()
    {
        $relations = $this->getMultiLevelSingleRelationRelations();
        $q         = $this->getLoadQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        // Actual test
        $this->extractor->extractObjectWithRelatedObjects(
            $stmt, 'RelationTestPerson', 2, $relations
        );

        $person = $this->idMap->getIdentity( 'RelationTestPerson', 2 );
        $this->assertNotNull( $person );
        $this->assertEquals(
            $this->session->load( 'RelationTestPerson', 2 ),
            $person
        );

        $addresses = $this->idMap->getRelatedObjects(
            $person, 'RelationTestAddress'
        );
        
        $this->assertNotNull( $addresses );

        $this->assertEquals( 3, count( $addresses ) );
        
        $realAddresses = $this->session->getRelatedObjects( $person, 'RelationTestAddress' );

        $this->assertEquals( $realAddresses, $addresses );

        foreach ( $addresses as $address )
        {
            $persons = $this->idMap->getRelatedObjects(
                $address, 'RelationTestPerson'
            );

            $this->assertNotNull( $persons );

            $realPersons = $this->session->getRelatedObjects(
                $address, 'RelationTestPerson'
            );

            $this->assertEquals( $realPersons, $persons );
        }
    }

    public function testFindMultiLevelSingleRelationNoRestrictions()
    {
        $relations = $this->getMultiLevelSingleRelationRelations();
        $q         = $this->getFindQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        // Actual test
        $persons = $this->extractor->extractObjectsWithRelatedObjects(
            $stmt, $q
        );

        $fakeFind = $this->session->createFindQuery( 'RelationTestPerson' );
        $fakeRes = $this->session->find( $fakeFind );

        $this->assertEquals(
            $fakeRes,
            $persons,
            'Returned extracted object set incorrect.'
        );

        foreach ( $persons as $person )
        {
            $addresses = $this->idMap->getRelatedObjects( $person, 'RelationTestAddress' );
            $this->assertEquals(
                $this->session->getRelatedObjects( $person, 'RelationTestAddress' ),
                $addresses
            );
            foreach( $addresses as $address )
            {
                $this->assertEquals(
                    $this->session->getRelatedObjects( $address, 'RelationTestPerson' ),
                    $this->idMap->getRelatedObjects( $address, 'RelationTestPerson' )
                );
            }
        }
    }

    public function testFindMultiLevelSingleRelationRestrictions()
    {
        $relations = $this->getMultiLevelSingleRelationRelations();
        $q         = $this->getFindQuery( $relations );

        $q->where(
            $q->expr->gt(
                $this->qi( 'addresses' ) . '.' . $this->qi( 'id' ),
                $q->bindValue( 2 )
            )
        );
        
        $stmt = $q->prepare();
        $stmt->execute();

        // Actual test
        $persons = $this->extractor->extractObjectsWithRelatedObjects(
            $stmt, $q
        );

        $fakeFind = $this->session->createFindQuery( 'RelationTestPerson' );
        $fakeRes = $this->session->find( $fakeFind );

        $this->assertEquals(
            $fakeRes,
            $persons,
            'Returned extracted object set incorrect.'
        );

        foreach ( $persons as $person )
        {
            $this->assertNull(
                $this->idMap->getRelatedObjects( $person, 'RelationTestAddress' )
            );
            $addresses = $this->idMap->getRelatedObjectSet( $person, 'addresses' );
            $this->assertNotNull( $addresses );
            foreach( $addresses as $address )
            {
                $this->assertNull( $this->idMap->getRelatedObjects( $address, 'RelationTestPerson' ) );
                $this->assertEquals(
                    $this->session->getRelatedObjects( $address, 'RelationTestPerson' ),
                    $this->idMap->getRelatedObjectSet( $address, 'habitants' )
                );
            }
        }
    }

    public function testLoadMultiLevelMultiRelation()
    {
        $relations = $this->getMultiLevelMultiRelationRelations();
        $q         = $this->getLoadQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        // Actual test
        $this->extractor->extractObjectWithRelatedObjects(
            $stmt, 'RelationTestPerson', 2, $relations
        );

        $person = $this->idMap->getIdentity( 'RelationTestPerson', 2 );
        $this->assertNotNull( $person );
        $this->assertEquals(
            $this->session->load( 'RelationTestPerson', 2 ),
            $person
        );

        $addresses = $this->idMap->getRelatedObjects(
            $person, 'RelationTestAddress'
        );
        
        $this->assertNotNull( $addresses );

        $this->assertEquals( 3, count( $addresses ) );
        
        $realAddresses = $this->session->getRelatedObjects( $person, 'RelationTestAddress' );

        $this->assertEquals( $realAddresses, $addresses );

        foreach ( $addresses as $address )
        {
            $persons = $this->idMap->getRelatedObjects(
                $address, 'RelationTestPerson'
            );

            $this->assertNotNull( $persons );

            $realPersons = $this->session->getRelatedObjects(
                $address, 'RelationTestPerson'
            );

            $this->assertEquals( $realPersons, $persons );

            foreach ( $persons as $relPerson )
            {
                $employers = $this->idMap->getRelatedObjects( $relPerson, 'RelationTestEmployer' );
                $this->assertNotNull( $employers );
                $realEmployers = $this->session->getRelatedObjects( $relPerson, 'RelationTestEmployer' );
                $this->assertEquals( $realEmployers, $employers );

                $birthdays = $this->idMap->getRelatedObjects( $relPerson, 'RelationTestBirthday' );

                if ( $relPerson->id == 3 )
                {
                    // Person with ID 3 has no birthday assigned
                    $this->assertEquals( array(), $birthdays );
                }
                else
                {
                    $this->assertNotNull( $birthdays );
                    $realBirthdays = $this->session->getRelatedObjects( $relPerson, 'RelationTestBirthday' );
                    $this->assertEquals( $realBirthdays, $birthdays );
                }
            }
        }

        $employers = $this->idMap->getRelatedObjects( $person, 'RelationTestEmployer' );
        $this->assertNotNull( $employers );
        $realEmployers = $this->session->getRelatedObjects( $person, 'RelationTestEmployer' );
        $this->assertEquals( $realEmployers, $employers );

        $birthdays = $this->idMap->getRelatedObjects( $person, 'RelationTestBirthday' );
        $this->assertNotNull( $birthdays );
        $realBirthdays = $this->session->getRelatedObjects( $person, 'RelationTestBirthday' );
        $this->assertEquals( $realBirthdays, $birthdays );
    }

    public function testFindMultiLevelMultiRelationNoRestrictions()
    {
        $relations = $this->getMultiLevelMultiRelationRelations();
        $q         = $this->getFindQuery( $relations );
        
        $stmt = $q->prepare();
        $stmt->execute();

        // Actual test
        $persons = $this->extractor->extractObjectsWithRelatedObjects(
            $stmt, $q
        );

        $fakeFind = $this->session->createFindQuery( 'RelationTestPerson' );
        $fakeRes = $this->session->find( $fakeFind );

        $this->assertEquals(
            $fakeRes,
            $persons,
            'Returned extracted object set incorrect.'
        );

        foreach ( $persons as $person )
        {
            $addresses = $this->idMap->getRelatedObjects( $person, 'RelationTestAddress' );
            $this->assertEquals(
                $this->session->getRelatedObjects( $person, 'RelationTestAddress' ),
                $addresses
            );
            foreach ( $addresses as $address )
            {
                $habitants = $this->idMap->getRelatedObjects( $address, 'RelationTestPerson' );
                $this->assertEquals(
                    $this->session->getRelatedObjects( $address, 'RelationTestPerson' ),
                    $habitants
                );
                foreach ( $habitants as $habitant )
                {
                    $habitantEmployers = $this->idMap->getRelatedObjects( $habitant, 'RelationTestEmployer' );
                    $this->assertEquals(
                        $this->session->getRelatedObjects( $habitant, 'RelationTestEmployer' ),
                        $habitantEmployers
                    );
                    $habitantBirthdays = $this->idMap->getRelatedObjects( $habitant, 'RelationTestBirthday' );
                    $this->assertEquals(
                        $this->session->getRelatedObjects( $habitant, 'RelationTestBirthday' ),
                        $habitantBirthdays
                    );
                }
            }
            $this->assertEquals(
                $this->session->getRelatedObjects( $person, 'RelationTestEmployer' ),
                $this->idMap->getRelatedObjects( $person, 'RelationTestEmployer' )
            );
            $this->assertEquals(
                $this->session->getRelatedObjects( $person, 'RelationTestBirthday' ),
                $this->idMap->getRelatedObjects( $person, 'RelationTestBirthday' )
            );
        }
    }

    public function testFindMultiLevelMultiRelationRestrictions()
    {
        $relations = $this->getMultiLevelMultiRelationRelations();
        $q         = $this->getFindQuery( $relations );

        $q->where(
            $q->expr->like(
                $this->qi( 'habitant_employer' ) . '.' . $this->qi( 'name' ),
                $q->bindValue( '%Web%' )
            ),
            $q->expr->lt( 
                $this->qi( 'birthday' ) . '.' . $this->qi( 'birthday' ),
                $q->bindValue( 0 )
           )
        );
        
        $stmt = $q->prepare();
        $stmt->execute();

        // Actual test
        $persons = $this->extractor->extractObjectsWithRelatedObjects(
            $stmt, $q
        );

        $fakeFind = $this->session->createFindQuery( 'RelationTestPerson' );
        $fakeFind->where(
            $fakeFind->expr->eq(
                'id',
                $fakeFind->bindValue( 2 )
            )
        );
        $fakeRes = $this->session->find( $fakeFind );

        $this->assertEquals(
            $fakeRes,
            $persons,
            'Returned extracted object set incorrect.'
        );

        foreach ( $persons as $person )
        {
            $this->assertNull( $this->idMap->getRelatedObjects( $person, 'RelationTestAddress' ) );
            $addresses = $this->idMap->getRelatedObjectSet( $person, 'addresses' );
            $this->assertEquals(
                $this->session->getRelatedObjects( $person, 'RelationTestAddress' ),
                $addresses
            );
            foreach ( $addresses as $address )
            {
                $this->assertNull( $this->idMap->getRelatedObjects( $address, 'RelationTestPerson' ) );
                $habitants = $this->idMap->getRelatedObjectSet( $address, 'habitants' );
                $this->assertEquals(
                    $this->session->getRelatedObjects( $address, 'RelationTestPerson' ),
                    $habitants
                );
                foreach ( $habitants as $habitant )
                {
                    $this->assertNull(
                        $this->idMap->getRelatedObjects( $habitant, 'RelationTestEmployer' )
                    );
                    $habitantEmployers = $this->idMap->getRelatedObjectSet( $habitant, 'habitant_employer' );
                    $this->assertNotNull(
                        $habitantEmployers
                    );
                    $this->assertNull( $this->idMap->getRelatedObjects( $habitant, 'RelationTestBirthday' ) );
                    $habitantBirthdays = $this->idMap->getRelatedObjectSet( $habitant, 'habitant_birthday' );
                    $this->assertEquals(
                        $this->session->getRelatedObjects( $habitant, 'RelationTestBirthday' ),
                        $habitantBirthdays
                    );
                }
            }
            $this->assertNull( $this->idMap->getRelatedObjects( $person, 'RelationTestEmployer' ) );
            $this->assertEquals(
                $this->session->getRelatedObjects( $person, 'RelationTestEmployer' ),
                $this->idMap->getRelatedObjectSet( $person, 'employer' )
            );
            $this->assertNull(
                $this->idMap->getRelatedObjects( $person, 'RelationTestBirthday' )
            );
            $this->assertNotNull(
                $this->idMap->getRelatedObjectSet( $person, 'birthday' )
            );
        }
    }

}

?>