<?php
//@encoding iso-8859-1

// Call Net_LDAP2_LDIFTest::main() if this source file is executed directly.
if (!defined("PHPUnit_MAIN_METHOD")) {
    define("PHPUnit_MAIN_METHOD", "Net_LDAP2_LDIFTest::main");
}

require_once "PHPUnit/Framework/TestCase.php";
require_once "PHPUnit/Framework/TestSuite.php";

require_once 'Net/LDAP2/LDIF.php';

/**
 * Test class for Net_LDAP2_LDIF.
 * Generated by PHPUnit_Util_Skeleton on 2007-12-20 at 10:11:52.
 */
class Net_LDAP2_LDIFTest extends PHPUnit_Framework_TestCase {
    /**
    * Default config for tests.
    *
    * The config is bound to the ldif test file
    * tests/ldif_data/unsorted_w50.ldif
    * so don't change or tests will fail
    *
    * @var array
    */
    var $defaultConfig = array(
        'onerror' => 'undef',
        'encode'  => 'base64',
        'wrap'    => 50,
        'change'  => 0,
        'sort'    => 0,
        'version' => 1   // mimic pre 2.0.0RC5 behavior, so test files need no adjusting
    );

    /**
    * Test entries data
    *
    * Please do not just modify these values, they
    * are closely related to the LDIF test data.
    *
    * @var string
    */
    var $testentries_data = array(
        'cn=test1,ou=example,dc=cno' => array(
            'cn'    => 'test1',
            'attr3' => array('foo', 'bar'),
            'attr1' => 12345,
            'attr4' => 'brrrzztt',
            'objectclass' => 'oc1',
            'attr2' => array('1234', 'baz')),

        'cn=test blabla,ou=example,dc=cno' => array(
            'cn'    => 'test blabla',
            'attr3' => array('foo', 'bar'),
            'attr1' => 12345,
            'attr4' => 'blabla',
            'objectclass' => 'oc2',
            'attr2' => array('1234', 'baz'),
            'verylong' => 'fhu08rhvt7b478vt5hv78h45nfgt45h78t34hhhhhhhhhv5bg8h6ttttttttt3489t57nhvgh4788trhg8999vnhtgthgui65hgb5789thvngwr789cghm738'),

        'cn=test ,ou=example,dc=cno' => array(
            'cn'    => 'test ',
            'attr3' => array('foo', 'bar'),
            'attr1' => 12345,
            'attr4' => 'blabla',
            'objectclass' => 'oc3',
            'attr2' => array('1234', 'baz'),
            'attr5' => 'endspace ',
            'attr6' => ':badinitchar'),

        ':cn=endspace,dc=cno ' => array(
            'cn'    => 'endspace')
    );

    /**
    * Test file written to
    *
    * @var string
    */
    var $outfile = 'test.out.ldif';

    /**
    * Test entries
    *
    * They will be created in main()
    *
    * @var array
    */
    var $testentries = array();

    /**
     * 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_LDAP2_LDIFTest");
        $result = PHPUnit_TextUI_TestRunner::run($suite);
    }

    /**
     * Open some outfile and ensure correct rights
     *
     * @access protected
     */
    protected function setUp() {
        // initialize test entries
        $this->testentries = array();
        foreach ($this->testentries_data as $dn => $attrs) {
            $entry = Net_LDAP2_Entry::createfresh($dn, $attrs);
            $this->assertType('Net_LDAP2_Entry', $entry, 'ERROR inittializing test entries');
            array_push($this->testentries, $entry);
        }

        // create outfile if not exists and enforce proper access rights
        if (!file_exists($this->outfile)) {
            if (!touch($this->outfile)) {
                $this->markTestSkipped('Unable to create '.$this->outfile.', skipping test');
            }
        }
        if (!chmod($this->outfile, 0644)) {
            $this->markTestSkipped('Unable to chmod(0644) '.$this->outfile.', skipping test');
        }
    }

    /**
     * Remove the outfile
     *
     * @access protected
     */
    protected function tearDown() {
       @unlink($this->outfile);
    }

    /**
     * Construction tests
     *
     * Construct LDIF object and see if we can get a handle
     */
    public function testConstruction() {
        $supported_modes = array('r', 'w', 'a');
        $plus            = array('', '+');

        // Test all open modes,
        // all of them should return a correct handle
        foreach ($supported_modes as $mode) {
            foreach ($plus as $p) {
                $ldif = new Net_LDAP2_LDIF($this->outfile, $mode, $this->defaultConfig);
                $this->assertTrue(is_resource($ldif->handle()));
            }
        }

        // Test illegal option passing
        $ldif = new Net_LDAP2_LDIF($this->outfile, $mode, array('somebad' => 'option'));
        $this->assertType('Net_LDAP2_Error', $ldif->error());

        // Test passing custom handle
        $handle = fopen($this->outfile, 'r');
        $ldif = new Net_LDAP2_LDIF($handle, $mode, $this->defaultConfig);
        $this->assertTrue(is_resource($ldif->handle()));

        // Reading test with invalid file mode
        $ldif = new Net_LDAP2_LDIF($this->outfile, 'y', $this->defaultConfig);
        $this->assertNull($ldif->handle());
        $this->assertType('Net_LDAP2_Error', $ldif->error());

        // Reading test with nonexistent file
        $ldif = new Net_LDAP2_LDIF('some/nonexistent/file_for_net_ldap_ldif', 'r', $this->defaultConfig);
        $this->assertNull($ldif->handle());
        $this->assertType('Net_LDAP2_Error', $ldif->error());

        // writing to nonexistent file
        $ldif = new Net_LDAP2_LDIF('testfile_for_net_ldap_ldif', 'w', $this->defaultConfig);
        $this->assertTrue(is_resource($ldif->handle()));
        @unlink('testfile_for_net_ldap_ldif');

        // writing to nonexistent path
        $ldif = new Net_LDAP2_LDIF('some/nonexistent/file_for_net_ldap_ldif', 'w', $this->defaultConfig);
        $this->assertNull($ldif->handle());
        $this->assertType('Net_LDAP2_Error', $ldif->error());

        // writing to existing file but without permission
        // note: chmod should succeed since we do that in setUp()
        if (chmod($this->outfile, 0444)) {
            $ldif = new Net_LDAP2_LDIF($this->outfile, 'w', $this->defaultConfig);
            $this->assertNull($ldif->handle());
            $this->assertType('Net_LDAP2_Error', $ldif->error());
        } else {
            $this->markTestSkipped("Could not chmod ".$this->outfile.", write test without permission skipped");
        }
    }

    /**
     * Tests if entries from an LDIF file are correctly constructed
     */
    public function testRead_entry() {
        /*
        * UNIX line endings
        */
        $ldif = new Net_LDAP2_LDIF(dirname(__FILE__).'/ldif_data/unsorted_w50.ldif', 'r', $this->defaultConfig);
        $this->assertTrue(is_resource($ldif->handle()));

        $entries = array();
        do {
            $entry = $ldif->read_entry();
            $this->assertFalse((boolean)$ldif->error(), 'failed building entry from LDIF: '.$ldif->error(true));
            $this->assertType('Net_LDAP2_Entry', $entry);
            array_push($entries, $entry);
        } while (!$ldif->eof());

        $this->compareEntries($this->testentries, $entries);

        /*
        * Windows line endings
        */
        $ldif = new Net_LDAP2_LDIF(dirname(__FILE__).'/ldif_data/unsorted_w50_WIN.ldif', 'r', $this->defaultConfig);
        $this->assertTrue(is_resource($ldif->handle()));

        $entries = array();
        do {
            $entry = $ldif->read_entry();
            $this->assertFalse((boolean)$ldif->error(), 'failed building entry from LDIF: '.$ldif->error(true));
            $this->assertType('Net_LDAP2_Entry', $entry);
            array_push($entries, $entry);
        } while (!$ldif->eof());

        $this->compareEntries($this->testentries, $entries);
    }

    /**
     * Tests if entries are correctly written
     *
     * This tests converting entries to LDIF lines, wrapping, encoding, etc
     */
    public function testWrite_entry() {
        $testconf = $this->defaultConfig;

        /*
        * test wrapped operation
        */
        $testconf['wrap'] = 50;
        $testconf['sort'] = 0;
        $expected = array_map('conv_lineend', file(dirname(__FILE__).'/ldif_data/unsorted_w50.ldif'));
        // strip 4 starting lines because of comments in the file header:
        array_shift($expected);array_shift($expected);
        array_shift($expected);array_shift($expected);

        // Write LDIF
        $ldif = new Net_LDAP2_LDIF($this->outfile, 'w', $testconf);
        $this->assertTrue(is_resource($ldif->handle()));
        $ldif->write_entry($this->testentries);
        $this->assertFalse((boolean)$ldif->error(), 'Failed writing entry to '.$this->outfile.': '.$ldif->error(true));
        $ldif->done();

        // Compare files
        $this->assertEquals($expected, file($this->outfile));


        $testconf['wrap'] = 30;
        $testconf['sort'] = 0;
        $expected = array_map('conv_lineend', file(dirname(__FILE__).'/ldif_data/unsorted_w30.ldif'));
        // strip 4 starting lines because of comments in the file header:
        array_shift($expected);array_shift($expected);
        array_shift($expected);array_shift($expected);

        // Write LDIF
        $ldif = new Net_LDAP2_LDIF($this->outfile, 'w', $testconf);
        $this->assertTrue(is_resource($ldif->handle()));
        $ldif->write_entry($this->testentries);
        $this->assertFalse((boolean)$ldif->error(), 'Failed writing entry to '.$this->outfile.': '.$ldif->error(true));
        $ldif->done();

        // Compare files
        $this->assertEquals($expected, file($this->outfile));



        /*
        * Test unwrapped operation
        */
        $testconf['wrap'] = 40;
        $testconf['sort'] = 1;
        $expected = array_map('conv_lineend', file(dirname(__FILE__).'/ldif_data/sorted_w40.ldif'));
        // strip 4 starting lines because of comments in the file header:
        array_shift($expected);array_shift($expected);
        array_shift($expected);array_shift($expected);

        // Write LDIF
        $ldif = new Net_LDAP2_LDIF($this->outfile, 'w', $testconf);
        $this->assertTrue(is_resource($ldif->handle()));
        $ldif->write_entry($this->testentries);
        $this->assertFalse((boolean)$ldif->error(), 'Failed writing entry to '.$this->outfile.': '.$ldif->error(true));
        $ldif->done();

        // Compare files
        $this->assertEquals($expected, file($this->outfile));


        $testconf['wrap'] = 50;
        $testconf['sort'] = 1;
        $expected = array_map('conv_lineend', file(dirname(__FILE__).'/ldif_data/sorted_w50.ldif'));
        // strip 4 starting lines because of comments in the file header:
        array_shift($expected);array_shift($expected);
        array_shift($expected);array_shift($expected);

        // Write LDIF
        $ldif = new Net_LDAP2_LDIF($this->outfile, 'w', $testconf);
        $this->assertTrue(is_resource($ldif->handle()));
        $ldif->write_entry($this->testentries);
        $this->assertFalse((boolean)$ldif->error(), 'Failed writing entry to '.$this->outfile.': '.$ldif->error(true));
        $ldif->done();

        // Compare files
        $this->assertEquals($expected, file($this->outfile));


        /*
        * Test raw option
        */
        $testconf['wrap'] = 50;
        $testconf['sort'] = 1;
        $testconf['raw']  = '/attr6/';
        $expected = array_map('conv_lineend', file(dirname(__FILE__).'/ldif_data/sorted_w50.ldif'));
        // strip 4 starting lines because of comments in the file header:
        array_shift($expected);array_shift($expected);
        array_shift($expected);array_shift($expected);

        // Write LDIF
        $ldif = new Net_LDAP2_LDIF($this->outfile, 'w', $testconf);
        $this->assertTrue(is_resource($ldif->handle()));
        $ldif->write_entry($this->testentries);
        $this->assertFalse((boolean)$ldif->error(), 'Failed writing entry to '.$this->outfile.': '.$ldif->error(true));
        $ldif->done();

        // Compare files, with expected attr adjusted
        $this->assertEquals($expected, file($this->outfile));


        /*
        * Test writing with non entry as parameter
        */
        $ldif = new Net_LDAP2_LDIF($this->outfile, 'w');
        $this->assertTrue(is_resource($ldif->handle()));
        $ldif->write_entry('malformed_parameter');
        $this->assertTrue((boolean)$ldif->error());
    }

    /**
    * Test version writing
    *
    * In the default config, we supply a version which causes the ldif writer to
    * spill out a version int. However, since 2.0.0RC5, the default behavior changed,
    * so that no version is written by default (compatibility to perl interface).
    * The following code tests that new behavior.
    */
    public function testWriteVersion() {
        $testconf = $this->defaultConfig;

        $expected = array_map('conv_lineend', file(dirname(__FILE__).'/ldif_data/unsorted_w50.ldif'));
        // strip 4 starting lines because of comments in the file header:
        array_shift($expected);array_shift($expected);
        array_shift($expected);array_shift($expected);

        // strip 1 additional line (the "version: 1" line that should not be written now)
        // and adjust test config
        array_shift($expected);
        unset($testconf['version']);

        // Write LDIF
        $ldif = new Net_LDAP2_LDIF($this->outfile, 'w', $testconf);
        $this->assertTrue(is_resource($ldif->handle()));
        $ldif->write_entry($this->testentries);
        $this->assertFalse((boolean)$ldif->error(), 'Failed writing entry to '.$this->outfile.': '.$ldif->error(true));
        $ldif->done();

        // Compare files
        $this->assertEquals($expected, file($this->outfile));
    }

    /**
     * Round trip test: Read LDIF, parse to entries, write that to LDIF and compare both files
     */
    public function testReadWriteRead() {
        $ldif = new Net_LDAP2_LDIF(dirname(__FILE__).'/ldif_data/unsorted_w50.ldif', 'r', $this->defaultConfig);
        $this->assertTrue(is_resource($ldif->handle()));

        // Read LDIF
        $entries = array();
        do {
            $entry = $ldif->read_entry();
            $this->assertFalse((boolean)$ldif->error(), 'failed building entry from LDIF: '.$ldif->error(true));
            $this->assertType('Net_LDAP2_Entry', $entry);
            array_push($entries, $entry);
        } while (!$ldif->eof());
        $ldif->done();

         // Write LDIF
         $ldif = new Net_LDAP2_LDIF($this->outfile, 'w', $this->defaultConfig);
         $this->assertTrue(is_resource($ldif->handle()));
         $ldif->write_entry($entries);
         $this->assertFalse((boolean)$ldif->error(), 'Failed writing entry to '.$this->outfile.': '.$ldif->error(true));
         $ldif->done();

         // Compare files
         $expected = array_map('conv_lineend', file(dirname(__FILE__).'/ldif_data/unsorted_w50.ldif'));
         // strip 4 starting lines because of comments in the file header:
         array_shift($expected);array_shift($expected);
         array_shift($expected);array_shift($expected);
         $this->assertEquals($expected, file($this->outfile));
    }

    /**
     * Tests if entriy changes are correctly written
     */
    public function testWrite_entryChanges() {
        $testentries = $this->testentries;
        $testentries[] = Net_LDAP2_Entry::createFresh('cn=foo,ou=example,dc=cno', array('cn' => 'foo'));
        $testentries[] = Net_LDAP2_Entry::createFresh('cn=footest,ou=example,dc=cno', array('cn' => 'foo'));

        $testconf = $this->defaultConfig;
        $testconf['change'] = 1;

        /*
        * no changes should produce empty file
        */
        $ldif = new Net_LDAP2_LDIF($this->outfile, 'w', $testconf);
        $this->assertTrue(is_resource($ldif->handle()));
        $ldif->write_entry($testentries);
        $this->assertFalse((boolean)$ldif->error(), 'Failed writing entry to '.$this->outfile.': '.$ldif->error(true));
        $ldif->done();
        $this->assertEquals(array(), file($this->outfile));

        /*
        * changes test
        */
        //prepare some changes
        $testentries[0]->delete('attr1'); // del whole attr
        $testentries[0]->delete(array('attr2' => 'baz')); // del spec. value
        $testentries[0]->delete(array('attr4', 'attr3' => 'bar')); // del mixed

        // prepare some replaces and adds
        $testentries[2]->replace(array('attr1' => 'newvaluefor1'));
        $testentries[2]->replace(array('attr2' => array('newvalue1for2', 'newvalue2for2')));
        $testentries[2]->replace(array('attr3' => ''));      // will result in delete
        $testentries[2]->replace(array('newattr' => 'foo')); // will result in add

        // delete whole entry
        $testentries[3]->delete();

        // rename and move
        $testentries[4]->dn('cn=Bar,ou=example,dc=cno');
        $testentries[5]->dn('cn=foobartest,ou=newexample,dc=cno');

        // carry out write
        $ldif = new Net_LDAP2_LDIF($this->outfile, 'w', $testconf);
        $this->assertTrue(is_resource($ldif->handle()));
        $ldif->write_entry($testentries);
        $this->assertFalse((boolean)$ldif->error(), 'Failed writing entry to '.$this->outfile.': '.$ldif->error(true));
        $ldif->done();

        //compare results
        $expected = array_map('conv_lineend', file(dirname(__FILE__).'/ldif_data/changes.ldif'));
        // strip 4 starting lines because of comments in the file header:
        array_shift($expected);array_shift($expected);
        array_shift($expected);array_shift($expected);
        $this->assertEquals($expected, file($this->outfile));
    }

    /**
    * Tests if syntax errors are detected
    *
    * The used LDIF files have several damaged entries but always one
    * correct too, to test if Net_LDAP2_LDIF is continue reading as it should
    * Each Entry must have 2 correct attributes.
    */
    public function testSyntaxerrors() {
        // Test malformed encoding
        // I think we can ignore this test, because if the LDIF is not encoded properly, we
        // might be able to successfully fetch the entries data. However, it is possible
        // that it will be corrupted, but thats not our fault then.
        // If we should catch that error, we must adjust Net_LDAP2_LDIF::next_lines().
        /*
        $ldif = new Net_LDAP2_LDIF(dirname(__FILE__).'/ldif_data/malformed_encoding.ldif', 'r', $this->defaultConfig);
        $this->assertFalse((boolean)$ldif->error());
        $entries = array();
        do {
            $entry = $ldif->read_entry();
            if ($entry) {
                // the correct attributes need to be parsed
                $this->assertThat(count(array_keys($entry->getValues())), $this->equalTo(2));
                $entries[] = $entry;
            }
        } while (!$ldif->eof());
        $this->assertTrue((boolean)$ldif->error());
        $this->assertThat($ldif->error_lines(), $this->greaterThan(1));
        $this->assertThat(count($entries), $this->equalTo(1));
        */

        // Test malformed syntax
        $ldif = new Net_LDAP2_LDIF(dirname(__FILE__).'/ldif_data/malformed_syntax.ldif', 'r', $this->defaultConfig);
        $this->assertFalse((boolean)$ldif->error());
        $entries = array();
        do {
            $entry = $ldif->read_entry();
            if ($entry) {
                // the correct attributes need to be parsed
                $this->assertThat(count(array_keys($entry->getValues())), $this->equalTo(2));
                $entries[] = $entry;
            }
        } while (!$ldif->eof());
        $this->assertTrue((boolean)$ldif->error());
        $this->assertThat($ldif->error_lines(), $this->greaterThan(1));
        $this->assertThat(count($entries), $this->equalTo(2));

        // test bad wrapping
        $ldif = new Net_LDAP2_LDIF(dirname(__FILE__).'/ldif_data/malformed_wrapping.ldif', 'r', $this->defaultConfig);
        $this->assertFalse((boolean)$ldif->error());
        $entries = array();
        do {
           $entry = $ldif->read_entry();
            if ($entry) {
                // the correct attributes need to be parsed
                $this->assertThat(count(array_keys($entry->getValues())), $this->equalTo(2));
                $entries[] = $entry;
            }
        } while (!$ldif->eof());
        $this->assertTrue((boolean)$ldif->error());
        $this->assertThat($ldif->error_lines(), $this->greaterThan(1));
        $this->assertThat(count($entries), $this->equalTo(2));
    }

    /**
     * Test error dropping functionality
     */
    public function testError() {
        // NO error:
        $ldif = new Net_LDAP2_LDIF(dirname(__FILE__).'/ldif_data/unsorted_w50.ldif', 'r', $this->defaultConfig);
        $this->assertFalse((boolean)$ldif->error());

        // Error giving error msg and line number:
        $ldif = new Net_LDAP2_LDIF(dirname(__FILE__).'/some_not_existing/path/for/net_ldap_ldif', 'r', $this->defaultConfig);
        $this->assertTrue((boolean)$ldif->error());
        $this->assertType('Net_LDAP2_Error', $ldif->error());
        $this->assertType('string', $ldif->error(true));
        $this->assertType('int', $ldif->error_lines());
        $this->assertThat(strlen($ldif->error(true)), $this->greaterThan(0));

        // Test for line number reporting
        $ldif = new Net_LDAP2_LDIF(dirname(__FILE__).'/ldif_data/malformed_syntax.ldif', 'r', $this->defaultConfig);
        $this->assertFalse((boolean)$ldif->error());
        do { $entry = $ldif->read_entry(); } while (!$ldif->eof());
        $this->assertTrue((boolean)$ldif->error());
        $this->assertThat($ldif->error_lines(), $this->greaterThan(1));
    }

    /**
     * Tests current_lines() and next_lines().
     *
     * This should always return the same lines unless forced
     */
    public function testLineMethods() {
        $ldif = new Net_LDAP2_LDIF(dirname(__FILE__).'/ldif_data/unsorted_w50.ldif', 'r', $this->defaultConfig);
        $this->assertFalse((boolean)$ldif->error());
        $this->assertEquals(array(), $ldif->current_lines(), 'Net_LDAP2_LDIF initialization error!');

        // read first lines
        $lines = $ldif->next_lines();
        $this->assertFalse((boolean)$ldif->error(), 'unable to read first lines');

        // read the first lines several times and test
        for ($i = 0; $i <= 10; $i++) {
            $r_lines = $ldif->next_lines();
            $this->assertFalse((boolean)$ldif->error());
            $this->assertEquals($lines, $r_lines);
        }

        // now force to iterate and see if the content changes
        $r_lines = $ldif->next_lines(true);
        $this->assertFalse((boolean)$ldif->error());
        $this->assertNotEquals($lines, $r_lines);

        // it could be confusing to some people, but calling
        // current_entry would not work now, like the description
        // of the method says.
        $no_entry = $ldif->current_lines();
        $this->assertEquals(array(), $no_entry);
    }

    /**
     * Tests current_entry(). This should always return the same object
     */
    public function testCurrent_entry() {
        $ldif = new Net_LDAP2_LDIF(dirname(__FILE__).'/ldif_data/unsorted_w50.ldif', 'r', $this->defaultConfig);
        $this->assertFalse((boolean)$ldif->error());

        // read first entry
        $entry = $ldif->read_entry();
        $this->assertFalse((boolean)$ldif->error(), 'First entry failed: '.$ldif->error(true));

        // test if current_Entry remains the first one
        for ($i = 0; $i <= 10; $i++) {
            $e = $ldif->current_entry();
            $this->assertFalse((boolean)$ldif->error(), $ldif->error(true));
            $this->assertEquals($entry, $e);
        }
    }





    /**
    * Compare Net_LDAP2_Entries
    *
    * This helper function compares two entries (or array of entries)
    * and tells if they are equal. They are equal if all DNs from
    * the first crowd exist in the second AND each attribute is present
    * and equal at the respicitve entry.
    * The search is case sensitive.
    *
    * @param array|Net_LDAP2_Entry $entry1
    * @param array|Net_LDAP2_Entry $entry2
    * @return true|false
    */
    function compareEntries($entry1, $entry2) {
        if (!is_array($entry1)) $entry1 = array($entry1);
        if (!is_array($entry2)) $entry2 = array($entry2);

        $entries_data1  = array();
        $entries_data2  = array();

        // step 1: extract and sort data
        foreach ($entry1 as $e) {
            $values = $e->getValues();
            foreach ($values as $attr_name => $attr_values) {
                if (!is_array($attr_values)) $attr_values = array($attr_values);
                $values[$attr_name] = $attr_values;
            }
            $entries_data1[$e->dn()] = $values;
        }
        foreach ($entry2 as $e) {
            $values = $e->getValues();
            foreach ($values as $attr_name => $attr_values) {
                if (!is_array($attr_values)) $attr_values = array($attr_values);
                $values[$attr_name] = $attr_values;
            }
            $entries_data2[$e->dn()] = $values;
        }

        // step 2: compare DNs (entries)
        $this->assertEquals(array_keys($entries_data1), array_keys($entries_data2), 'Entries DNs not equal! (missing entry or wrong DN)');

        // step 3: look for attribute existence and compare values
        foreach ($entries_data1 as $dn => $attributes) {
            $this->assertEquals($entries_data1[$dn], $entries_data2[$dn], 'Entries '.$dn.' attributes are not equal');
            foreach ($attributes as $attr_name => $attr_values) {
                $this->assertEquals(0, count(array_diff($entries_data1[$dn][$attr_name], $entries_data2[$dn][$attr_name])), 'Entries '.$dn.' attribute '.$attr_name.' values are not equal');
            }
        }

        return true;
    }

}

// Call Net_LDAP2_LDIFTest::main() if this source file is executed directly.
if (PHPUnit_MAIN_METHOD == "Net_LDAP2_LDIFTest::main") {
    Net_LDAP2_LDIFTest::main();
}

if (!function_exists('conv_lineend')) {
    /**
    * Function transfers line endings to current OS
    *
    * This is neccessary to make write tests platform indendent.
    *
    * @param string $line Line
    * @return string
    */
    function conv_lineend($line) {
        return rtrim($line).PHP_EOL;
    }
}
?>