Subversion-Projekte lars-tiefland.php_share

<?php

// Call Net_LDAP2Test::main() if this source file is executed directly.

if (!defined("PHPUnit_MAIN_METHOD")) {

    define("PHPUnit_MAIN_METHOD", "Net_LDAP2Test::main");

}

require_once "PHPUnit/Framework/TestCase.php";

require_once "PHPUnit/Framework/TestSuite.php";

require_once 'Net/LDAP2.php';

require_once 'Net/LDAP2/Entry.php';

/**

 * Test class for Net_LDAP2.

 * Generated by PHPUnit_Util_Skeleton on 2007-10-09 at 10:32:36.

 */

class Net_LDAP2Test extends PHPUnit_Framework_TestCase {

    /**

    * Stores the LDAP configuration

    */

    var $ldapcfg = false;

    /**

     * Runs the test methods of this class.

     *

     * @access public

     * @static

     */

    public static function main() {

        require_once "PHPUnit/TextUI/TestRunner.php";

        $suite  = new PHPUnit_Framework_TestSuite("Net_LDAP2Test");

        $result = PHPUnit_TextUI_TestRunner::run($suite);

    }

    /**

     * Load ldap config and adjust appropriately

     *

     * @access protected

     */

    protected function setUp() {

        $this->ldapcfg = $this->getTestConfig();

    }

    /**

     * Tears down the fixture, for example, close a network connection.

     * This method is called after a test is executed.

     *

     * @access protected

     */

    protected function tearDown() {

    }

    /**

     * This checks if a valid LDAP testconfig is present and loads it.

     *

     * If so, it is loaded and returned as array. If not, false is returned.

     *

     * @return false|array

     */

    public function getTestConfig() {

        $config = false;

        $file = dirname(__FILE__).'/ldapconfig.ini';

        if (file_exists($file) && is_readable($file)) {

            $config = parse_ini_file($file, true);

        } else {

            return false;

        }

        // validate ini

        $v_error = $file.' is probably invalid. Did you quoted values correctly?';

        $this->assertTrue(array_key_exists('global', $config), $v_error);

        $this->assertTrue(array_key_exists('test', $config), $v_error);

        $this->assertEquals(7, count($config['global']), $v_error);

        $this->assertEquals(7, count($config['test']), $v_error);

        // reformat things a bit, for convinience

        $config['global']['server_binddn'] =

            $config['global']['server_binddn'].','.$config['global']['server_base_dn'];

        $config['test']['existing_attrmv'] = explode('|', $config['test']['existing_attrmv']);

        return $config;

    }

    /**

    * Establishes a working connection

    *

    * @return Net_LDAP2

    */

    public function &connect() {

        // Check extension

        if (true !== Net_LDAP2::checkLDAPExtension()) {

            $this->markTestSkipped('PHP LDAP extension not found or not loadable. Skipped Test.');

        }

        // Simple working connect and privilegued bind

        $lcfg = array(

                'host'   => $this->ldapcfg['global']['server_address'],

                'port'   => $this->ldapcfg['global']['server_port'],

                'basedn' => $this->ldapcfg['global']['server_base_dn'],

                'binddn' => $this->ldapcfg['global']['server_binddn'],

                'bindpw' => $this->ldapcfg['global']['server_bindpw'],

                'filter' => '(ou=*)',

            );

        $ldap = Net_LDAP2::connect($lcfg);

        $this->assertType('Net_LDAP2', $ldap, 'Connect failed but was supposed to work. Check credentials and host address. If those are correct, file a bug!');

        return $ldap;

    }

/* ---------- TESTS ---------- */

    /**

     * testCheckLDAPExtension().

     *

     * @todo can we unload modules at runtime??

     */

    public function testCheckLDAPExtension() {

        if (extension_loaded('ldap')) {

            // If extension is already loaded, then we must get true.

            $this->assertTrue(Net_LDAP2::checkLDAPExtension());

        } else {

            // If not, we should be able to load it - but may fail

            $this->assertThat(Net_LDAP2::checkLDAPExtension(),

                $this->logicalOr($this->isInstanceOf('Net_LDAP2_Error'), $this->equalTo(true)));

        }

    }

    /**

     * Tests if getVersion() works correctly

     */

    public function testGetVersion() {

        $this->assertTrue(defined('NET_LDAP2_VERSION'));

        $this->assertEquals(NET_LDAP2_VERSION, Net_LDAP2::getVersion());

    }

    /**

     * Tests if the server can connect and bind correctly

     */

    public function testConnectAndPrivileguedBind() {

        // Check extension

        if (true !== Net_LDAP2::checkLDAPExtension()) {

            $this->markTestSkipped('PHP LDAP extension not found or not loadable. Skipped Test.');

        }

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            // This connect is supposed to fail

            $lcfg = array(

                    'host' => 'pear.net-ldap.test.hostunknown.cno',

                );

            $ldap = Net_LDAP2::connect($lcfg);

            $this->assertType('Net_LDAP2_Error', $ldap, 'Connect succeeded but was supposed to fail!');

            // Failing with multiple hosts

            $lcfg = array(

                    'host' => array('pear.net-ldap.test.hostunknown1.cno', 'pear.net-ldap.test.hostunknown2.cno'),

                );

            $ldap = Net_LDAP2::connect($lcfg);

            $this->assertType('Net_LDAP2_Error', $ldap, 'Connect succeeded but was supposed to fail!');

            // Simple working connect and privilegued bind

            $ldap =& $this->connect();

            // Working connect and privilegued bind with first host down

            $lcfg = array(

                    'host'   => array(

                            'pear.net-ldap.test.hostunknown1.cno',

                            $this->ldapcfg['global']['server_address']

                        ),

                    'port'   => $this->ldapcfg['global']['server_port'],

                    'binddn' => $this->ldapcfg['global']['server_binddn'],

                    'bindpw' => $this->ldapcfg['global']['server_bindpw'],

                );

            $ldap = Net_LDAP2::connect($lcfg);

            $this->assertType('Net_LDAP2', $ldap, 'Connect failed but was supposed to work. Check credentials and host address. If those are correct, file a bug!');

        }

    }

    /**

     * Tests if the server can connect and bind anonymously, if supported (->cfg and ldap mode)

     */

    public function testConnectAndAnonymousBind() {

        // Check extension

        if (true !== Net_LDAP2::checkLDAPExtension()) {

            $this->markTestSkipped('PHP LDAP extension not found or not loadable. Skipped Test.');

        }

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } elseif ($this->ldapcfg['global']['server_cap_anonymous'] == true) {

            // Simple working connect and anonymous bind

            $lcfg = array(

                    'host'   => $this->ldapcfg['global']['server_address'],

                    'port'   => $this->ldapcfg['global']['server_port'],

                );

            $ldap = Net_LDAP2::connect($lcfg);

            $this->assertType('Net_LDAP2', $ldap, 'Connect failed but was supposed to work. Check address and if server supports anonymous bind. If those are correct, file a bug!');

        } else {

            $this->markTestSkipped('Server does not support anonymous bind (see ldapconfig.ini). Skipping test.');

        }

    }

    /**

     * testStartTLS() if server supports it

     */

    public function testStartTLS() {

        // Check extension

        if (true !== Net_LDAP2::checkLDAPExtension()) {

            $this->markTestSkipped('PHP LDAP extension not found or not loadable. Skipped Test.');

        }

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } elseif ($this->ldapcfg['global']['server_cap_tls'] == true) {

            // Simple working connect and privilegued bind

            $lcfg = array(

                    'host'     => $this->ldapcfg['global']['server_address'],

                    'port'     => $this->ldapcfg['global']['server_port'],

                    'binddn'   => $this->ldapcfg['global']['server_binddn'].','.$this->ldapcfg['global']['server_binddn'],

                    'bindpw'   => $this->ldapcfg['global']['server_bindpw'],

                    'starttls' => true

                );

            $ldap = Net_LDAP2::connect();

            $this->assertType('Net_LDAP2', $ldap, 'Connect failed but was supposed to work. Check credentials and host address. If those are correct, file a bug!');

        } else {

             $this->markTestSkipped('Server does not support TLS (see ldapconfig.ini). Skipping test.');

        }

    }

    /**

     * Test if adding and deleting a fresh entry works

     */

    public function testAdd() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            // Adding a fresh entry

            $cn          = 'Net-LDAP-TestEntry';

            $dn          = 'cn='.$cn.','.$this->ldapcfg['global']['server_base_dn'];

            $fresh_entry = Net_LDAP2_Entry::createFresh($dn,

                array(

                    'objectClass' => array('top','person'),

                    'cn'          => $cn,

                    'sn'          => 'TestEntry'

                )

            );

            $this->assertType('Net_LDAP2_Entry', $fresh_entry);

            $this->assertTrue($ldap->add($fresh_entry));

            // Deleting this Entry

            $this->assertTrue($ldap->delete($fresh_entry), 'Deletion of entry failed!');

        }

    }

    /**

     * testDelete().

     *

     * Basic deletion is tested in testAdd(), so here we just test if

     * advanced deletion tasks work properly.

     */

    public function testDelete() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            // some parameter checks

            $this->assertType('Net_LDAP2_Error', $ldap->delete(1234));

            $this->assertType('Net_LDAP2_Error', $ldap->delete($ldap));

            // in order to test subtree deletion, we need some little tree

            // which we need to establish first

            $base   = $this->ldapcfg['global']['server_base_dn'];

            $testdn = 'ou=Net_LDAP2_Test_subdelete,'.$base;

            $ou = Net_LDAP2_Entry::createFresh($testdn,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'Net_LDAP2_Test_subdelete'

                ));

            $ou_1 = Net_LDAP2_Entry::createFresh('ou=test1,'.$testdn,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'test1'

                ));

            $ou_1_l1 = Net_LDAP2_Entry::createFresh('l=subtest,ou=test1,'.$testdn,

                array(

                    'objectClass' => array('top','locality'),

                    'l' => 'test1'

                ));

            $ou_2 = Net_LDAP2_Entry::createFresh('ou=test2,'.$testdn,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'test2'

                ));

            $ou_3 = Net_LDAP2_Entry::createFresh('ou=test3,'.$testdn,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'test3'

                ));

            $this->assertTrue($ldap->add($ou));

            $this->assertTrue($ldap->add($ou_1));

            $this->assertTrue($ldap->add($ou_1_l1));

            $this->assertTrue($ldap->add($ou_2));

            $this->assertTrue($ldap->add($ou_3));

            $this->assertTrue($ldap->dnExists($ou->dn()));

            $this->assertTrue($ldap->dnExists($ou_1->dn()));

            $this->assertTrue($ldap->dnExists($ou_1_l1->dn()));

            $this->assertTrue($ldap->dnExists($ou_2->dn()));

            $this->assertTrue($ldap->dnExists($ou_3->dn()));

            // Tree established now. We can run some tests now :D

            // Try to delete some non existent entry inside that subtree (fails)

            $this->assertType('Net_LDAP2_Error', $ldap->delete(

                'cn=not_existent,ou=test1,'.$testdn));

            // Try to delete main test ou without recursive set (fails too)

            $this->assertType('Net_LDAP2_Error', $ldap->delete($testdn));

            // Retry with subtree delete, this should work

            $this->assertTrue($ldap->delete($testdn, true));

            // The DN is not allowed to exist anymore

            $this->assertFalse($ldap->dnExists($testdn));

        }

    }

    /**

     * testModify().

     */

    public function testModify() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            // We need a test entry:

            $local_entry = Net_LDAP2_Entry::createFresh(

                'ou=Net_LDAP2_Test_modify,'.$this->ldapcfg['global']['server_base_dn'],

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou'              => 'Net_LDAP2_Test_modify',

                    'street'          => 'Beniroad',

                    'telephoneNumber' => array('1234', '5678'),

                    'postalcode'      => '12345',

                    'postalAddress'   => 'someAddress',

                    'facsimileTelephoneNumber' => array('123','456')

                ));

            $this->assertTrue($ldap->add($local_entry));

            $this->assertTrue($ldap->dnExists($local_entry->dn()));

            // Prepare some changes

            $changes = array(

                'add' => array(

                                'businessCategory' => array('foocat', 'barcat'),

                                'description' => 'testval'

                ),

                'delete' => array('postalAddress'),

                'replace' => array('telephoneNumber' => array('345', '567')),

                'changes' => array(

                                'replace' => array('street' => 'Highway to Hell'),

                                'add' => array('l' => 'someLocality'),

                                'delete' => array(

                                    'postalcode',

                                    'facsimileTelephoneNumber' => array('123'))

                )

            );

            // Perform those changes

            $this->assertTrue($ldap->modify($local_entry, $changes));

            // verify correct attribute changes

            $actual_entry = $ldap->getEntry($local_entry->dn(), array(

                'objectClass', 'ou','postalAddress', 'street', 'telephoneNumber', 'postalcode',

                'facsimileTelephoneNumber', 'l', 'businessCategory', 'description'));

            $this->assertType('Net_LDAP2_Entry', $actual_entry);

            $expected_attributes = array(

                'objectClass' => array('top', 'organizationalUnit'),

                'ou' => 'Net_LDAP2_Test_modify',

                'street' => 'Highway to Hell',

                'l'      => 'someLocality',

                'telephoneNumber' => array('345', '567'),

                'businessCategory' => array('foocat', 'barcat'),

                'description' => 'testval',

                'facsimileTelephoneNumber' => '456'

            );

            $local_attributes  = $local_entry->getValues();

            $actual_attributes = $actual_entry->getValues();

            // to enable easy check, we need to sort the

            // values of the remaining multival attrs as

            // well as the attribute names

            ksort($expected_attributes);

            ksort($local_attributes);

            ksort($actual_attributes);

            sort($expected_attributes['businessCategory']);

            sort($local_attributes['businessCategory']);

            sort($actual_attributes['businessCategory']);

            // cleanup directory

            $this->assertTrue($ldap->delete($actual_entry),

                'Cleanup of test entry failed. Please remove manually: '.$local_entry->dn());

            // The attributes must match the expected values.

            // Both, the entry inside the directory and our

            // apps local copy must reflect the same values

            $this->assertEquals($expected_attributes, $actual_attributes, 'The directory entries attributes are not OK!');

            $this->assertEquals($expected_attributes, $local_attributes, 'The local entries attributes are not OK!');

        }

    }

    /**

     * testSearch().

     */

    public function testSearch() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            // some testdata, so we can test sizelimit

            $base = $this->ldapcfg['global']['server_base_dn'];

            $ou1  = Net_LDAP2_Entry::createFresh('ou=Net_LDAP2_Test_search1,'.$base,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'Net_LDAP2_Test_search1'

                ));

            $ou1_1  = Net_LDAP2_Entry::createFresh('ou=Net_LDAP2_Test_search1_1,'.$ou1->dn(),

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'Net_LDAP2_Test_search2'

                ));

            $ou2  = Net_LDAP2_Entry::createFresh('ou=Net_LDAP2_Test_search2,'.$base,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'Net_LDAP2_Test_search2'

                ));

            $this->assertTrue($ldap->add($ou1));

            $this->assertTrue($ldap->dnExists($ou1->dn()));

            $this->assertTrue($ldap->add($ou1_1));

            $this->assertTrue($ldap->dnExists($ou1_1->dn()));

            $this->assertTrue($ldap->add($ou2));

            $this->assertTrue($ldap->dnExists($ou2->dn()));

            // Search for testfilter, should at least return our two test entries

            $res = $ldap->search(null, '(ou=Net_LDAP2*)',

                array('attributes' => '1.1')

            );

            $this->assertType('Net_LDAP2_Search', $res);

            $this->assertThat($res->count(), $this->greaterThanOrEqual(2));

            // Same, but with Net_LDAP2_Filter object

            $filtero = Net_LDAP2_Filter::create('ou', 'begins', 'Net_LDAP2');

            $this->assertType('Net_LDAP2_Filter', $filtero);

            $res = $ldap->search(null, $filtero,

                array('attributes' => '1.1')

            );

            $this->assertType('Net_LDAP2_Search', $res);

            $this->assertThat($res->count(), $this->greaterThanOrEqual(2));

            // Search using default filter for base-onelevel scope

            // should at least return our two test entries

            $res = $ldap->search(null, null,

                array('scope' => 'one', 'attributes' => '1.1')

            );

            $this->assertType('Net_LDAP2_Search', $res);

            $this->assertThat($res->count(), $this->greaterThanOrEqual(2));

            // Base-search using custom base (string)

            // should only return the test entry $ou1 and not the entry below it.

            $res = $ldap->search($ou1->dn(), null,

                array('scope' => 'base', 'attributes' => '1.1')

            );

            $this->assertType('Net_LDAP2_Search', $res);

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

            // Search using custom base, this time using an entry object

            // This tests if passing an entry object as base works

            // should only return the test entry $ou1

            $res = $ldap->search($ou1, '(ou=*)',

                array('scope' => 'base', 'attributes' => '1.1')

            );

            $this->assertType('Net_LDAP2_Search', $res);

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

            // Search using default filter for base-onelevel scope with sizelimit

            // should of course return more than one entry,

            // but not more than sizelimit

            $res = $ldap->search(null, null,

                array('scope' => 'one', 'sizelimit' => 1, 'attributes' => '1.1')

            );

            $this->assertType('Net_LDAP2_Search', $res);

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

            $this->assertTrue($res->sizeLimitExceeded()); // sizelimit should be exceeded now

            // Bad filter

            $res = $ldap->search(null, 'somebadfilter',

                array('attributes' => '1.1')

            );

            $this->assertType('Net_LDAP2_Error', $res);

            // Bad base

            $res = $ldap->search('badbase', null,

                array('attributes' => '1.1')

            );

            $this->assertType('Net_LDAP2_Error', $res);

            // Passing Error object as base and as filter object

            $error = new Net_LDAP2_Error('Testerror');

            $res = $ldap->search($error, null, // error base

                array('attributes' => '1.1')

            );

            $this->assertType('Net_LDAP2_Error', $res);

            $res = $ldap->search(null, $error, // error filter

                array('attributes' => '1.1')

            );

            $this->assertType('Net_LDAP2_Error', $res);

            // Nullresult

            $res = $ldap->search(null, '(cn=nevermatching_filter)',

                array('scope' => 'base', 'attributes' => '1.1')

            );

            $this->assertType('Net_LDAP2_Search', $res);

            $this->assertEquals(0, $res->count());

            // cleanup

            $this->assertTrue($ldap->delete($ou1_1), 'Cleanup failed, please delete manually');

            $this->assertTrue($ldap->delete($ou1),   'Cleanup failed, please delete manually');

            $this->assertTrue($ldap->delete($ou2),   'Cleanup failed, please delete manually');

        }

    }

    /**

     * @todo Implement testSetOption().

     */

    public function testSetOption() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $this->markTestIncomplete("This test has not been implemented yet.");

        }

    }

    /**

     * @todo Implement testGetOption().

     */

    public function testGetOption() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $this->markTestIncomplete("This test has not been implemented yet.");

        }

    }

    /**

     * @todo Implement testGetLDAPVersion().

     */

    public function testGetLDAPVersion() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $this->markTestIncomplete("This test has not been implemented yet.");

        }

    }

    /**

     * @todo Implement testSetLDAPVersion().

     */

    public function testSetLDAPVersion() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $this->markTestIncomplete("This test has not been implemented yet.");

        }

    }

    /**

     * testDnExists().

     */

    public function testDnExists() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            $dn   = $this->ldapcfg['test']['existing_entry'].','.$this->ldapcfg['global']['server_base_dn'];

            // Testing existing and not existing DN; neither should produce an error

            $this->assertTrue($ldap->dnExists($dn));

            $this->assertFalse($ldap->dnExists('cn=not_existent,'.$dn));

            // Passing an Entry object (should work)

            // It should return false, because don't add the test entry

            $base = $this->ldapcfg['global']['server_base_dn'];

            $ou1  = Net_LDAP2_Entry::createFresh('ou=Net_LDAP2_Test_search1,'.$base,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'Net_LDAP2_Test_search1'

                ));

            $this->assertFalse($ldap->dnExists($ou1));

            // Passing an float instead of a string

            $this->assertType('Net_LDAP2_Error', $ldap->dnExists(1.234));

            // Pasing an error object

            $error = new Net_LDAP2_Error('Testerror');

            $this->assertType('Net_LDAP2_Error', $ldap->dnExists($error));

        }

    }

    /**

     * testGetEntry().

     */

    public function testGetEntry() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            $dn   = $this->ldapcfg['test']['existing_entry'].','.$this->ldapcfg['global']['server_base_dn'];

            // existing DN

            $this->assertType('Net_LDAP2_Entry', $ldap->getEntry($dn), "$dn was supposed to be found. Please check your ldapconfig.ini!");

            // Not existing DN

            $this->assertType('Net_LDAP2_Error',

                $ldap->getEntry('cn=notexistent,'.$this->ldapcfg['global']['server_base_dn']));

        }

    }

    /**

     * testMove().

     */

    public function testMove() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            // For Moving tests, we need some little tree again

            $base   = $this->ldapcfg['global']['server_base_dn'];

            $testdn = 'ou=Net_LDAP2_Test_moves,'.$base;

            $ou = Net_LDAP2_Entry::createFresh($testdn,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'Net_LDAP2_Test_moves'

                ));

            $ou_1 = Net_LDAP2_Entry::createFresh('ou=source,'.$testdn,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'source'

                ));

            $ou_1_l1 = Net_LDAP2_Entry::createFresh('l=moveitem,ou=source,'.$testdn,

                array(

                    'objectClass' => array('top','locality'),

                    'l' => 'moveitem',

                    'description' => 'movetest'

                ));

            $ou_2 = Net_LDAP2_Entry::createFresh('ou=target,'.$testdn,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'target'

                ));

            $ou_3 = Net_LDAP2_Entry::createFresh('ou=target_otherdir,'.$testdn,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'target_otherdir'

                ));

            $this->assertTrue($ldap->add($ou));

            $this->assertTrue($ldap->add($ou_1));

            $this->assertTrue($ldap->add($ou_1_l1));

            $this->assertTrue($ldap->add($ou_2));

            $this->assertTrue($ldap->add($ou_3));

            $this->assertTrue($ldap->dnExists($ou->dn()));

            $this->assertTrue($ldap->dnExists($ou_1->dn()));

            $this->assertTrue($ldap->dnExists($ou_1_l1->dn()));

            $this->assertTrue($ldap->dnExists($ou_2->dn()));

            $this->assertTrue($ldap->dnExists($ou_3->dn()));

            // Tree established

            // Local rename

            $olddn = $ou_1_l1->currentDN();

            $this->assertTrue($ldap->move($ou_1_l1,

                str_replace('moveitem', 'move_item', $ou_1_l1->dn())));

            $this->assertTrue($ldap->dnExists($ou_1_l1->dn()));

            $this->assertFalse($ldap->dnExists($olddn));

            // Local move

            $olddn = $ou_1_l1->currentDN();

            $this->assertTrue($ldap->move($ou_1_l1, 'l=move_item,'.$ou_2->dn()));

            $this->assertTrue($ldap->dnExists($ou_1_l1->dn()));

            $this->assertFalse($ldap->dnExists($olddn));

            // Local move backward, with rename

            // Here we use the DN of the object, to test DN conversion.

            // Note that this will outdate the object since it does not

            // has knowledge about the move.

            $olddn = $ou_1_l1->currentDN();

            $newdn = 'l=moveditem,'.$ou_2->dn();

            $this->assertTrue($ldap->move($olddn, $newdn));

            $this->assertTrue($ldap->dnExists($newdn));

            $this->assertFalse($ldap->dnExists($olddn));

            $ou_1_l1 = $ldap->getEntry($newdn); // Refetch since the objects DN was outdated

            // Fake-cross directory move using two separate

            // links to the same directory.

            // This other directory is represented by ou=target_otherdir

            $ldap2 = $this->connect();

            $olddn = $ou_1_l1->currentDN();

            $this->assertTrue($ldap->move($ou_1_l1, 'l=movedcrossdir,'.$ou_3->dn(), $ldap2));

            $this->assertFalse($ldap->dnExists($olddn));

            $this->assertTrue($ldap2->dnExists($ou_1_l1->dn()));

            // Try to move over an existing entry

             $this->assertType('Net_LDAP2_Error', $ldap->move($ou_2, $ou_3->dn(), $ldap2));

            // Try cross directory move without providing an valid entry but a DN

            $this->assertType('Net_LDAP2_Error',

                $ldap->move($ou_1_l1->dn(), 'l=movedcrossdir2,'.$ou_2->dn(), $ldap2));

            // Try passing an invalid entry object

            $this->assertType('Net_LDAP2_Error',

                $ldap->move($ldap, 'l=move_item,'.$ou_2->dn()));

            // Try passing an invalid ldap object

            $this->assertType('Net_LDAP2_Error',

                $ldap->move($ou_1_l1, 'l=move_item,'.$ou_2->dn(), $ou_1));

            // cleanup test tree

            $this->assertTrue($ldap->delete($testdn, true), "Could not delete $testdn, please cleanup manually");

        }

    }

    /**

     * testCopy().

     */

    public function testCopy() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            // some testdata...

            $base = $this->ldapcfg['global']['server_base_dn'];

            $ou1  = Net_LDAP2_Entry::createFresh('ou=Net_LDAP2_Test_pool,'.$base,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'Net_LDAP2_Test_copy'

                ));

            $ou2  = Net_LDAP2_Entry::createFresh('ou=Net_LDAP2_Test_tgt,'.$base,

                array(

                    'objectClass' => array('top','organizationalUnit'),

                    'ou' => 'Net_LDAP2_Test_copy'

                ));

            $this->assertTrue($ldap->add($ou1));

            $this->assertTrue($ldap->dnExists($ou1->dn()));

            $this->assertTrue($ldap->add($ou2));

            $this->assertTrue($ldap->dnExists($ou2->dn()));

            $entry  = Net_LDAP2_Entry::createFresh('l=cptest,'.$ou1->dn(),

                array(

                    'objectClass' => array('top','locality'),

                    'l' => 'cptest'

                ));

            $this->assertTrue($ldap->add($entry));

            $this->assertTrue($ldap->dnExists($entry->dn()));

            // copy over the entry to another tree with rename

            $entrycp = $ldap->copy($entry, 'l=test_copied,'.$ou2->dn());

            $this->assertType('Net_LDAP2_Entry', $entrycp);

            $this->assertNotEquals($entry->dn(), $entrycp->dn());

            $this->assertTrue($ldap->dnExists($entrycp->dn()));

            // copy same again (fails, entry exists)

            $entrycp_f = $ldap->copy($entry, 'l=test_copied,'.$ou2->dn());

            $this->assertType('Net_LDAP2_Error', $entrycp_f);

            // use only DNs to copy (fails)

            $entrycp = $ldap->copy($entry->dn(), 'l=test_copied2,'.$ou2->dn());

            //cleanup

            $this->assertTrue($ldap->delete($ou1, true));

            $this->assertTrue($ldap->delete($ou2, true));

        }

    }

    /**

     * testIsError().

     */

    public function testIsError() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $error = PEAR::raiseError('TestError');

            $this->assertTrue(Net_LDAP2::isError($error));

            $this->assertFalse(Net_LDAP2::isError('noerror'));

        }

    }

    /**

     * checks retrival of RootDSE object

     */

    public function testRootDse() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            $this->assertType('Net_LDAP2_RootDSE', $ldap->rootDSE());

        }

    }

    /**

     * Checks retrival of schema through LDAP object

     */

    public function testSchema() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            $this->assertType('Net_LDAP2_Schema', $ldap->schema());

        }

    }

    /**

     * testUtf8Encode()

     */

    public function testUtf8Encode() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap    =& $this->connect();

            $utf8    = array('cn' => 'this needs utf8: öäü');

            $no_utf8 = array('cn' => 'this needs no utf8');

            $this->assertNotEquals($utf8, $ldap->utf8Encode($utf8));

            $this->assertEquals($no_utf8, $ldap->utf8Encode($no_utf8));

            // wrong parameter

            $this->assertType('Net_LDAP2_Error', $ldap->utf8Encode('foobar'));

            $this->assertType('Net_LDAP2_Error', $ldap->utf8Encode(array('foobar')));

        }

    }

    /**

     * testUtf8Decode().

     */

    public function testUtf8Decode() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap  =& $this->connect();

            $entry = $ldap->getEntry($this->ldapcfg['test']['existing_entry'].','.$this->ldapcfg['global']['server_base_dn'],

                array($this->ldapcfg['test']['utf8_attr'], $this->ldapcfg['test']['noutf8_attr']));

            $this->assertType('Net_LDAP2_Entry', $entry, 'Unable to fetch test entry, check ldapconfig.ini');

            $raw_utf8 = array($this->ldapcfg['test']['utf8_attr'] => $entry->getValue($this->ldapcfg['test']['utf8_attr'], 'single'));

            $this->assertTrue(is_string($raw_utf8[$this->ldapcfg['test']['utf8_attr']]));

            $no_utf8  = array($this->ldapcfg['test']['noutf8_attr'] => $entry->getValue($this->ldapcfg['test']['noutf8_attr'], 'single'));

            $this->assertTrue(is_string($no_utf8[$this->ldapcfg['test']['noutf8_attr']]));

            $this->assertNotEquals($raw_utf8, $ldap->utf8Decode($raw_utf8));

            $this->assertEquals($no_utf8, $ldap->utf8Decode($no_utf8));

            // wrong parameter

            $this->assertType('Net_LDAP2_Error', $ldap->utf8Decode('foobar'));

            $this->assertType('Net_LDAP2_Error', $ldap->utf8Decode(array('foobar')));

        }

    }

    /**

     * testGetLink().

     */

    public function testGetLink() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            $this->assertTrue(is_resource($ldap->getLink()));

        }

    }

    /**

    * Test for bug #18202: "Adding attributes to a Fresh Entry saving and laterly updating fails"

    */

    public function testEntryAddIsNotPersistent() {

        if (!$this->ldapcfg) {

            $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');

        } else {

            $ldap =& $this->connect();

            // setup test entry

            $cn   = 'Net_LDAP2_Test_bug_18202';

            $dn   = 'cn='.$cn.','.$this->ldapcfg['global']['server_base_dn'];

            $data = array(

                'objectClass' => array('top', 'inetOrgPerson'),

                'givenName'   => 'bug 18202',

                'sn'          => 'testentry',

                'cn'          => $cn

            );

            // Test case

            $entry = Net_LDAP2_Entry::createFresh($dn, $data);

            $this->assertType('Net_LDAP2_Entry', $entry);

            $this->assertTrue( $entry->add(array('uid' => 'Fu Bar')) );

            $this->assertTrue( $ldap->add($entry) );

            $this->assertTrue( $entry->replace(array('uid' => 'Foo Bar')) );

            $this->assertTrue( $result = $entry->update() );

            // cleanup

            $this->assertTrue($ldap->delete($entry),

                    'Cleanup of test entry failed. Please remove manually: '.$entry->dn());

        }

    }

}

// Call Net_LDAP2Test::main() if this source file is executed directly.

if (PHPUnit_MAIN_METHOD == "Net_LDAP2Test::main") {

    Net_LDAP2Test::main();

}

?>