Rename LDIFTestCase in AbstractLdifTestCase. Adding more tests.

Violette Roche-Montane

15.07.2012 86471a919f9899d8b6c1fb308bb640d3c63f7274

Rename LDIFTestCase in AbstractLdifTestCase.
Adding more tests.

 opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/AbstractLDIFTestCase.java

New file
@@ -0,0 +1,43 @@
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
 * or http://forgerock.org/license/CDDLv1.0.html.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at legal-notices/CDDLv1_0.txt.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Copyright 2010 Sun Microsystems, Inc.
 *      Portions copyright 2012 ForgeRock AS.
 */
package org.forgerock.opendj.ldif;

import org.forgerock.testng.ForgeRockTestCase;
import org.testng.annotations.Test;

/**
 * An abstract class that all LDIF unit tests should extend. LDIF represents the
 * classes found directly under the package org.forgerock.opendj.ldif.
 */

@Test(groups = { "precommit", "types", "sdk" })
public abstract class AbstractLDIFTestCase extends ForgeRockTestCase {
}





 opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/ConnectionEntryReaderTestCase.java

@@ -59,7 +59,7 @@
 * This class tests the ConnectionEntryReader functionality.
 */
@SuppressWarnings("javadoc")
public class ConnectionEntryReaderTestCase extends LDIFTestCase {
public class ConnectionEntryReaderTestCase extends AbstractLDIFTestCase {

    /**
     * Test a ConnectionEntryReader. Searching and finding entry.

 opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/ConnectionEntryWriterTestCase.java

@@ -46,7 +46,7 @@
 * This class tests the ConnectionEntryWriter functionality.
 */
@SuppressWarnings("javadoc")
public class ConnectionEntryWriterTestCase extends LDIFTestCase {
public class ConnectionEntryWriterTestCase extends AbstractLDIFTestCase {

    /**
     * ConnectionEntryWriter writes entry to the directory server.

 opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/LDIFChangeRecordReaderTestCase.java

@@ -69,7 +69,7 @@
 * This class tests the LDIFChangeRecordReader functionality.
 */
@SuppressWarnings("javadoc")
public final class LDIFChangeRecordReaderTestCase extends LDIFTestCase {
public final class LDIFChangeRecordReaderTestCase extends AbstractLDIFTestCase {

    /**
     * Provide a standard LDIF Change Record, valid, for tests below.

 opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/LDIFChangeRecordWriterTestCase.java

@@ -60,7 +60,7 @@
 * This class tests the LDIFChangeRecordWriter functionality.
 */
@SuppressWarnings("javadoc")
public class LDIFChangeRecordWriterTestCase extends LDIFTestCase {
public class LDIFChangeRecordWriterTestCase extends AbstractLDIFTestCase {

    /**
     * Provide a standard LDIF Change Record, valid, for tests below. 1 dn + 1

 opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/LDIFEntryReaderTestCase.java

@@ -62,7 +62,7 @@
 * This class tests the LDIFEntryReader functionality.
 */
@SuppressWarnings("javadoc")
public final class LDIFEntryReaderTestCase extends LDIFTestCase {
public final class LDIFEntryReaderTestCase extends AbstractLDIFTestCase {
    /**
     * Provide a standard entry for the tests below.
     *

 opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/LDIFEntryWriterTestCase.java

@@ -46,7 +46,7 @@
/**
 * This class tests the LDIFEntryWriter functionality.
 */
public final class LDIFEntryWriterTestCase extends LDIFTestCase {
public final class LDIFEntryWriterTestCase extends AbstractLDIFTestCase {

    /**
     * Standard entry used for the following tests.

 opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/ldif/LDIFTestCase.java

@@ -21,19 +21,1112 @@
 * CDDL HEADER END
 *
 *
 *      Copyright 2010 Sun Microsystems, Inc.
 *      Copyright 2009-2010 Sun Microsystems, Inc.
 *      Portions copyright 2012 ForgeRock AS.
 */

package org.forgerock.opendj.ldif;

import org.forgerock.testng.ForgeRockTestCase;
import static org.fest.assertions.Assertions.assertThat;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.SortedMap;
import java.util.TreeMap;

import org.forgerock.i18n.LocalizedIllegalArgumentException;
import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.ldap.DecodeException;
import org.forgerock.opendj.ldap.Entry;
import org.forgerock.opendj.ldap.LinkedHashMapEntry;
import org.forgerock.opendj.ldap.Modification;
import org.forgerock.opendj.ldap.ModificationType;
import org.forgerock.opendj.ldap.SearchScope;
import org.forgerock.opendj.ldap.requests.AddRequest;
import org.forgerock.opendj.ldap.requests.DeleteRequest;
import org.forgerock.opendj.ldap.requests.ModifyRequest;
import org.forgerock.opendj.ldap.requests.Requests;
import org.forgerock.opendj.ldap.requests.SearchRequest;
import org.forgerock.opendj.ldap.schema.Schema;
import org.testng.annotations.Test;

/**
 * An abstract class that all LDIF unit tests should extend. LDIF represents the
 * classes found directly under the package org.forgerock.opendj.ldif.
 * This class tests the LDIF functionality.
 */
@SuppressWarnings("javadoc")
public class LDIFTestCase extends AbstractLDIFTestCase {

@Test(groups = { "precommit", "types", "sdk" })
public abstract class LDIFTestCase extends ForgeRockTestCase {
    /**
     * Provide a standard entry for the tests below.
     *
     * @return well formed LDIF entry
     */
    public final String[] getStandardEntry() {
        // @formatter:off
        final String[] entry = {
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson",
            "objectClass: organizationalperson",
            "objectClass: top",
            "postalAddress: Aaccf Amar$01251 Chestnut Street$Panama City, DE  50369",
            "postalCode: 50369",
            "uid: user.0",
            "description: This is the description for Aaccf Amar.",
            "userPassword: {SSHA}hpbT8dLi8xgYy2kl4aP6QKGzsFdhESWpPmDTEw==",
            "employeeNumber: 0",
            "initials: ASA",
            "givenName: Aaccf",
            "pager: +1 779 041 6341",
            "mobile: +1 010 154 3228",
            "cn: Aaccf Amar",
            "telephoneNumber: +1 685 622 6202",
            "sn: Amar",
            "street: 01251 Chestnut Street",
            "homePhone: +1 225 216 5900",
            "mail: user.0@maildomain.net",
            "l: Panama City", "st: DE",
            "pwdChangedTime: 20120903142126.219Z",
            "entryDN: uid=user.0,ou=people,dc=example,dc=org",
            "entryUUID: ad55a34a-763f-358f-93f9-da86f9ecd9e4",
            "modifyTimestamp: 20120903142126Z",
            "modifiersName: cn=Internal Client,cn=Root DNs,cn=config"
        };
        // @formatter:on
        return entry;
    }

    /**
     * Number of attributes of the standard entry.
     */
    public final int nbStandardEntryAttributes = new LinkedHashMapEntry(getStandardEntry())
            .getAttributeCount();

    /**
     * Testing LDIF Search with match.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifSearchWithMatch() throws Exception {

        final EntryReader reader = new LDIFEntryReader(getStandardEntry());
        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE,
                        "(uid=user.0)");

        final EntryReader resultReader = LDIF.search(reader, sr);
        final Entry entry = resultReader.readEntry();

        assertThat(entry.getName().toString()).isEqualTo("uid=user.0,ou=People,dc=example,dc=com");
        assertThat(entry.getAttributeCount()).isEqualTo(nbStandardEntryAttributes);

        reader.close();
        resultReader.close();
    }

    /**
     * Testing LDIF Search with no match.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifSearchWithNoMatch() throws Exception {

        final EntryReader reader = new LDIFEntryReader(getStandardEntry());
        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=org", SearchScope.WHOLE_SUBTREE,
                        "(uid=user.0)");
        final EntryReader resultReader = LDIF.search(reader, sr);
        // No result found in the reader.
        assertThat(resultReader.hasNext()).isFalse();
        resultReader.close();
    }

    /**
     * LDIF Search with null parameters throw a NullPointerException.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifSearchDoesntAllowNull() throws Exception {

        LDIF.search(null, null);
    }

    /**
     * LDIF Search doesn't allow a null search request.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifSearchDoesntAllowNullSearchRequest() throws Exception {

        final EntryReader reader = new LDIFEntryReader(getStandardEntry());
        try {
            LDIF.search(reader, null);
        } finally {
            reader.close();
        }
    }

    /**
     * LDIF Search with null reader is allowed but throws null pointer
     * exception.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifSearchAllowsNullReader() throws Exception {

        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE,
                        "(uid=user.0)");

        final EntryReader resultReader = LDIF.search(null, sr);
        resultReader.readEntry();
        resultReader.close();
    }

    /**
     * Test the search request using a schema and no specifying attribute
     * description.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifSearchWithSchemaMatchNoAttributeDescription() throws Exception {

        // @formatter:off
        final EntryReader reader = new LDIFEntryReader(
                "dn: uid=user.0,ou=People,dc=example,dc=com",
                "objectClass: person",
                "objectClass: inetorgperson",
                "objectClass: organizationalperson",
                "objectClass: top",
                "uid: user.0"
        );
        // @formatter:on

        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "uid=*");

        final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema());
        if (resultReader.hasNext()) {
            Entry entry = resultReader.readEntry();
            assertThat(entry.getName().toString()).isEqualTo(
                    "uid=user.0,ou=People,dc=example,dc=com");
            assertThat(entry.getAttributeCount()).isEqualTo(2);
            assertThat(entry.getAttribute("uid")).isNotNull();
            assertThat(entry.getAttribute("uid").getAttributeDescription()).isNotNull();
            assertThat(entry.getAttribute("uid").firstValueAsString()).isNotNull();
        }
        resultReader.close();
    }

    /**
     * Test the search request using a schema and no specifying attribute
     * description. TypesOnly = true.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifSearchWithSchemaMatchNoAttributeDescriptionTypeOnly()
            throws Exception {

        // @formatter:off
        final EntryReader reader = new LDIFEntryReader(
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson",
            "objectClass: organizationalperson",
            "objectClass: top",
            "uid: user.0"
        );
        // @formatter:on

        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "uid=*")
                        .setTypesOnly(true);

        final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema());
        if (resultReader.hasNext()) {
            Entry entry = resultReader.readEntry();
            assertThat(entry.getName().toString()).isEqualTo(
                    "uid=user.0,ou=People,dc=example,dc=com");
            assertThat(entry.getAttributeCount()).isEqualTo(2);
            assertThat(entry.getAttribute("uid")).isNotNull();
            assertThat(entry.getAttribute("uid").getAttributeDescription()).isNotNull();
            assertThat(entry.getAttribute("uid")).isEmpty();
        }
        resultReader.close();
    }

    /**
     * LDIF Search with Schema use : all attributes.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifSearchWithSchemaMatchFullAttributes() throws Exception {

        // @formatter:off
        final EntryReader reader = new LDIFEntryReader(
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson",
            "objectClass: organizationalperson",
            "objectClass: top",
            "uid: user.0"
        );
        // @formatter:on

        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE,
                        "(uid=user.0)", "*");

        final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema());
        if (resultReader.hasNext()) {
            Entry entry = resultReader.readEntry();
            assertThat(entry.getName().toString()).isEqualTo(
                    "uid=user.0,ou=People,dc=example,dc=com");
            assertThat(entry.getAttributeCount()).isEqualTo(2);
            assertThat(entry.getAttribute("uid")).isNotNull();
            assertThat(entry.getAttribute("uid").getAttributeDescription()).isNotNull();
            assertThat(entry.getAttribute("uid").firstValueAsString()).isEqualTo("user.0");
        }
        resultReader.close();
    }

    /**
     * LDIF Search with Schema use : all attributes. Types only.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifSearchWithSchemaMatchFullAttributesTypeOnly() throws Exception {

        // @formatter:off
        final EntryReader reader = new LDIFEntryReader(
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson",
            "objectClass: organizationalperson",
            "objectClass: top",
            "uid: user.0"
        );
        // @formatter:on

        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE,
                        "(uid=user.0)", "*").setTypesOnly(true);

        final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema());

        if (resultReader.hasNext()) {
            Entry entry = resultReader.readEntry();
            assertThat(entry.getName().toString()).isEqualTo(
                    "uid=user.0,ou=People,dc=example,dc=com");
            assertThat(entry.getAttributeCount()).isEqualTo(2);
            assertThat(entry.getAttribute("objectClass")).isNotNull();
            assertThat(entry.getAttribute("uid")).isNotNull();
            assertThat(entry.getAttribute("uid").getAttributeDescription()).isNotNull();
            assertThat(entry.getAttribute("uid")).isEmpty();

            try {
                assertThat(entry.getAttribute("uid").firstValueAsString()).isNull();
            } catch (NoSuchElementException ex) {
                // No values, only type.
                // Expected exception on entry.getAttribute("uid").firstValueAsString()
            }
        }
        resultReader.close();
    }

    /**
     * Testing the new search request with the + operator == operational
     * attributes only.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifSearchWithSchemaMatchOnlyOperationalAttributes() throws Exception {

        // @formatter:off
        final EntryReader reader = new LDIFEntryReader(
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson",
            "objectClass: organizationalperson",
            "objectClass: top",
            "uid: user.0",
            "entryDN: uid=user.0,ou=People,dc=example,dc=com",
            "entryUUID: ad55a34a-763f-358f-93f9-da86f9ecd9e4",
            "modifyTimestamp: 20120903142126Z",
            "modifiersName: cn=Internal Client,cn=Root DNs,cn=config"
        );
        // @formatter:on

        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE,
                        "(uid=user.0)", "+");

        final EntryReader resultReader = LDIF.search(reader, sr, Schema.getCoreSchema());
        if (resultReader.hasNext()) {
            Entry entry = resultReader.readEntry();
            assertThat(entry.getName().toString()).isEqualTo(
                    "uid=user.0,ou=People,dc=example,dc=com");
            assertThat(entry.getAttributeCount()).isEqualTo(4);
            assertThat(entry.getAttribute("entryDN").firstValueAsString()).isEqualTo(
                    "uid=user.0,ou=People,dc=example,dc=com");
            assertThat(entry.getAttribute("entryUUID")).isNotEmpty();
            assertThat(entry.getAttribute("modifyTimestamp")).isNotEmpty();
            assertThat(entry.getAttribute("modifiersName")).isNotEmpty();
        }
        resultReader.close();
    }

    /**
     * Testing the new search request with the + operator == operational
     * attributes only. Combined here with the TypeOnly = true.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifSearchWithSchemaMatchOnlyOperationalAttributesTypeOnly()
            throws Exception {

        // @formatter:off
        final EntryReader reader = new LDIFEntryReader(
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson",
            "objectClass: organizationalperson",
            "objectClass: top",
            "uid: user.0",
            "entryDN: uid=user.0,ou=People,dc=example,dc=com",
            "entryUUID: ad55a34a-763f-358f-93f9-da86f9ecd9e4",
            "modifyTimestamp: 20120903142126Z",
            "modifiersName: cn=Internal Client,cn=Root DNs,cn=config"
        );
        // @formatter:on

        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE,
                        "(uid=user.0)", "+").setTypesOnly(true);

        final EntryReader resultReader = LDIF.search(reader, sr, Schema.getCoreSchema());
        if (resultReader.hasNext()) {
            Entry entry = resultReader.readEntry();
            assertThat(entry.getName().toString()).isEqualTo(
                    "uid=user.0,ou=People,dc=example,dc=com");
            assertThat(entry.getAttributeCount()).isEqualTo(4);
            assertThat(entry.getAttribute("entryDN")).isEmpty();
            assertThat(entry.getAttribute("entryUUID")).isEmpty();
            assertThat(entry.getAttribute("modifyTimestamp")).isEmpty();
            assertThat(entry.getAttribute("modifiersName")).isEmpty();
        }
        resultReader.close();
    }

    /**
     * LDIF Search with Schema use filter on uid attribute.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifSearchWithSchemaMatchSpecifiedAttribute() throws Exception {

        // @formatter:off
        final EntryReader reader = new LDIFEntryReader(
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson",
            "objectClass: organizationalperson",
            "objectClass: top",
            "uid: user.0"
        );
        // @formatter:on

        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE,
                        "(uid=user.0)", "uid");

        final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema());
        if (resultReader.hasNext()) {
            Entry entry = resultReader.readEntry();
            assertThat(entry.getName().toString()).isEqualTo(
                    "uid=user.0,ou=People,dc=example,dc=com");
            assertThat(entry.getAttributeCount()).isEqualTo(1);
        }
        resultReader.close();
    }

    /**
     * LDIF Search with Schema use filter on uid attribute.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifSearchWithSchemaMatchSpecifiedAttributeTypeOnly() throws Exception {

        // @formatter:off
        final EntryReader reader = new LDIFEntryReader(
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson",
            "objectClass: organizationalperson",
            "objectClass: top",
            "uid: user.0"
        );
        // @formatter:on

        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE,
                        "(uid=user.0)", "uid").setTypesOnly(true);

        final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema());
        if (resultReader.hasNext()) {
            Entry entry = resultReader.readEntry();
            assertThat(entry.getName().toString()).isEqualTo(
                    "uid=user.0,ou=People,dc=example,dc=com");
            assertThat(entry.getAttributeCount()).isEqualTo(1);
            assertThat(entry.getAttribute("uid").getAttributeDescription()).isNotNull();
            assertThat(entry.getAttribute("uid")).isEmpty();
            try {
                assertThat(entry.getAttribute("uid").firstValueAsString()).isNull();
            } catch (NoSuchElementException ex) {
                // No values, only type.
                // Expected exception on entry.getAttribute("uid").firstValueAsString()
            }
        }
        resultReader.close();
    }

    /**
     * LDIF Search with Schema use with filter not contained in this entry.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifSearchWithSchemaNoMatchSpecifiedAttribute() throws Exception {

        // @formatter:off
        final EntryReader reader = new LDIFEntryReader(
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson",
            "objectClass: organizationalperson",
            "objectClass: top",
            "uid: user.0"
        );
        // @formatter:on

        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE,
                        "(uid=user.0)", "email");

        final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema());
        if (resultReader.hasNext()) {
            Entry entry = resultReader.readEntry();
            assertThat(entry.getName().toString()).isEqualTo(
                    "uid=user.0,ou=People,dc=example,dc=com");
            assertThat(entry.getAttributeCount()).isEqualTo(0);
        }
        resultReader.close();
    }

    /**
     * The attribute description contains an internal white space : must throw
     * an exception.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = LocalizedIllegalArgumentException.class)
    public final void testLdifSearchWithSchemaThrowsException() throws Exception {

        // @formatter:off
        final EntryReader reader = new LDIFEntryReader(
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson",
            "objectClass: organizationalperson",
            "objectClass: top",
            "uid: user.0"
        );
        // @formatter:on

        final SearchRequest sr =
                Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE,
                        "(uid=user.0)", "wro ng"); // wrong syntax filter

        final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema());
        if (resultReader.hasNext()) {
            resultReader.readEntry();
        }
        resultReader.close();
    }

    /**
     * Verifying LDIF Collection reader.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifNewEntryCollectionReader() throws Exception {

        // @formatter:off
        Entry e = new LinkedHashMapEntry(
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson"
        );
        Entry e1 = new LinkedHashMapEntry("dn: uid=user.1,ou=People,dc=example,dc=com", "objectClass: person");
        Entry e2 = new LinkedHashMapEntry("dn: uid=user.2,ou=People,dc=example,dc=com", "objectClass: person");
        // @formatter:on

        Collection<Entry> collection = new ArrayList<Entry>();
        collection.add(e);
        collection.add(e1);
        collection.add(e2);

        final EntryReader resultReader = LDIF.newEntryCollectionReader(collection);
        Entry entry = null;
        int cCount = 0;
        while (resultReader.hasNext()) {
            entry = resultReader.readEntry();
            assertThat(entry.getName().toString()).isNotNull();
            assertThat(entry.getAttributeCount()).isGreaterThanOrEqualTo(1);
            cCount++;
        }
        assertThat(cCount).isEqualTo(3);
        resultReader.close();
    }

    /**
     * The LDIF newEntryCollectionReader allows a null parameter.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifNewEntryCollectionDoesntAllowNull() throws Exception {

        EntryReader resultReader = null;
        try {
            resultReader = LDIF.newEntryCollectionReader(null);
            resultReader.readEntry();
        } finally {
            resultReader.close();
        }
    }

    /**
     * LDIF newEntryIteratorReader.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifNewEntryIteratorReader() throws Exception {

        // @formatter:off
        final Entry e = new LinkedHashMapEntry(
            "dn: uid=user.0,ou=People,dc=example,dc=com",
            "objectClass: person",
            "objectClass: inetorgperson"
        );
        final Entry e1 = new LinkedHashMapEntry("dn: uid=user.1,ou=People,dc=example,dc=com", "objectClass: person");
        // @formatter:on

        final SortedMap<DN, Entry> sourceEntries = new TreeMap<DN, Entry>();
        sourceEntries.put(DN.valueOf("uid=user.0,ou=People,dc=example,dc=com"), e);
        sourceEntries.put(DN.valueOf("uid=user.1,ou=People,dc=example,dc=com"), e1);
        final Iterator<Entry> sourceIterator = sourceEntries.values().iterator();

        final EntryReader resultReader = LDIF.newEntryIteratorReader(sourceIterator);
        Entry entry = null;
        int cCount = 0;
        while (resultReader.hasNext()) {
            entry = resultReader.readEntry();
            assertThat(entry.getName().toString()).isNotNull();
            assertThat(entry.getName().toString()).contains("ou=People,dc=example,dc=com");
            assertThat(entry.getAttributeCount()).isGreaterThanOrEqualTo(1);
            cCount++;
        }
        assertThat(cCount).isEqualTo(2);
        resultReader.close();
    }

    /**
     * LDIF newEntryIteratorReader doesn't allow null.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifNewEntryIteratorReaderDoesntAllowsNull() throws Exception {

        EntryReader resultReader = null;
        try {
            resultReader = LDIF.newEntryIteratorReader(null);
            resultReader.readEntry();
        } finally {
            resultReader.close();
        }
    }

    /**
     * Verify LDIF CopyToChangeRecord is working.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifCopyToChangeRecord() throws Exception {

        // @formatter:off
        final LDIFChangeRecordReader reader = new LDIFChangeRecordReader(
            "# Entry to delete",
            "dn: uid=scarter,ou=People,dc=example,dc=com",
            "changetype: delete"
        );
        // @formatter:on
        final java.util.List<String> actual = new ArrayList<String>();
        final LDIFChangeRecordWriter writer = new LDIFChangeRecordWriter(actual);

        try {
            LDIF.copyTo(reader, writer);
            // Comment is skipped.
            assertThat(actual.get(0)).isEqualTo("dn: uid=scarter,ou=People,dc=example,dc=com");
            assertThat(actual.get(1)).isEqualTo("changetype: delete");
            assertThat(actual.get(2)).isEqualTo("");
            assertThat(actual.size()).isEqualTo(3); // 2 lines + 1 empty
        } finally {
            reader.close();
            writer.close();
        }
    }

    /**
     * LDIF copyTo - ChangeRecord doesn't allow null parameters.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifCopyToChangeRecordDoesntAllowNull() throws Exception {

        LDIF.copyTo((ChangeRecordReader) null, (ChangeRecordWriter) null);
    }

    /**
     * LDIF copyTo - ChangeRecord doesn't allow a null writer.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifCopyToChangeRecordDoesntAllowNullWriter() throws Exception {

        // @formatter:off
        final LDIFChangeRecordReader reader = new LDIFChangeRecordReader(
            "# Entry to delete",
            "dn: uid=scarter,ou=People,dc=example,dc=com",
            "changetype: delete"
        );
        // @formatter:on
        LDIF.copyTo(reader, null);
    }

    /**
     * LDIF copyTo - ChangeRecord doesn't allow a null reader.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifCopyToChangeRecordDoesntAllowNullReader() throws Exception {

        final java.util.List<String> actual = new ArrayList<String>();
        final LDIFChangeRecordWriter writer = new LDIFChangeRecordWriter(actual);

        LDIF.copyTo(null, writer);
    }

    /**
     * LDIF copyTo - EntryWriter doesn't allow null.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifCopyToEntryWriter() throws Exception {

        // @formatter:off
        final LDIFEntryReader reader = new LDIFEntryReader(
            "# Entry to delete",
            "dn: uid=scarter,ou=People,dc=example,dc=com",
            "changetype: delete"
        );
        // @formatter:on

        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);

        try {
            LDIF.copyTo(reader, writer);
            // Comment is skipped.
            assertThat(actual.get(0)).isEqualTo("dn: uid=scarter,ou=People,dc=example,dc=com");
            assertThat(actual.get(1)).isEqualTo("changetype: delete");
            assertThat(actual.get(2)).isEqualTo("");
            assertThat(actual.size()).isEqualTo(3); // 2 lines + 1 empty
        } finally {
            reader.close();
            writer.close();
        }
    }

    /**
     * LDIF copyTo - EntryWriter doesn't allow a null writer.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifCopyToEntryWriterDoesntAllowNullWriter() throws Exception {

        // @formatter:off
        final LDIFEntryReader reader = new LDIFEntryReader(
            "# Entry to delete",
            "dn: uid=scarter,ou=People,dc=example,dc=com",
            "changetype: delete"
        );
        // @formatter:on
        LDIF.copyTo(reader, null);
    }

    /**
     * LDIF copyTo - EntryWriter doesn't allow a null reader.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifCopyToEntryWriterDoesntAllowNullReader() throws Exception {

        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);

        LDIF.copyTo(null, writer);
    }

    /**
     * Testing the diff function. Following example from the admin guide.
     *
     * @see <a
     *      href=http://opendj.forgerock.org/doc/admin-guide/index.html#ldif-diff
     *      -1 result”>Admin Guide</a>
     * @throws Exception
     */
    @Test()
    public final void testLdifDiffEntriesModsOnSameDN() throws Exception {

        // @formatter:off
        final LDIFEntryReader source = new LDIFEntryReader(
            "dn: uid=newuser,ou=People,dc=example,dc=com",
            "uid: newuser",
            "objectClass: person",
            "objectClass: organizationalPerson",
            "objectClass: inetOrgPerson",
            "objectClass: top",
            "cn: New User",
            "sn: User",
            "ou: People",
            "mail: newuser@example.com",
            "userPassword: changeme" // diff here
        );

        final LDIFEntryReader target = new LDIFEntryReader(
            "dn: uid=newuser,ou=People,dc=example,dc=com",
            "uid: newuser",
            "objectClass: person",
            "objectClass: organizationalPerson",
            "objectClass: inetOrgPerson",
            "objectClass: top",
            "cn: New User",
            "sn: User",
            "ou: People",
            "mail: newuser@example.com",
            "userPassword: secret12", // diff here
            "description: A new description." // diff here
        );
        // @formatter:on

        final ChangeRecordReader reader = LDIF.diff(source, target);
        final ChangeRecord cr = reader.readChangeRecord();
        assertThat(cr.getName().toString()).isEqualTo("uid=newuser,ou=People,dc=example,dc=com");
        assertThat(cr).isInstanceOf(ModifyRequest.class);

        // @formatter:off
        /* Expected : 2 add / 1 delete.
         * dn: uid=newuser,ou=People,dc=example,dc=com
         * changetype: modify
         * add: userPassword
         * userPassword: secret12
         * -
         * delete: userPassword
         * userPassword: changeme
         * -
         * add: description
         * description: A new description.
         */
         // @formatter:on

        assertThat(((ModifyRequest) cr).getModifications().size()).isEqualTo(3);
        for (Modification mod : ((ModifyRequest) cr).getModifications()) {
            if (mod.getModificationType() == ModificationType.ADD) {
                assertThat((mod.getAttribute().getAttributeDescription().toString())
                        .equals("description")
                        || (mod.getAttribute().getAttributeDescription().toString())
                                .equals("userPassword"));

                assertThat((mod.getAttribute().firstValueAsString()).equals("A new description.")
                        || (mod.getAttribute().firstValueAsString()).equals("secret12"));
            }
            if (mod.getModificationType() == ModificationType.DELETE) {
                assertThat(mod.getAttribute().getAttributeDescription().toString()).isEqualTo(
                        "userPassword");
                assertThat(mod.getAttribute().firstValueAsString()).isEqualTo("changeme");
            }
        }
        reader.close();
        target.close();
    }

    /**
     * Testing the diff : entry in source but not in target.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifDiffEntriesEntryInSourceNotInTarget() throws Exception {

        // @formatter:off
        final LDIFEntryReader source = new LDIFEntryReader(
            "dn: uid=newuser,ou=People,dc=example,dc=com",
            "cn: New User"
        );

        final LDIFEntryReader target = new LDIFEntryReader(
            "dn: uid=scarter,ou=People,dc=example,dc=com",
            "cn: Samantha Carter"
        );
        // @formatter:on

        final ChangeRecordReader reader = LDIF.diff(source, target);

        // @formatter:off
        /* output is :
          dn: uid=newuser,ou=People,dc=example,dc=com
          changetype: delete

          dn: uid=scarter,ou=People,dc=example,dc=com
          changetype: add
          cn: Samantha Carter
         */
        // @formatter:on

        ChangeRecord cr = reader.readChangeRecord();
        assertThat(cr.getName().toString()).isEqualTo("uid=newuser,ou=People,dc=example,dc=com");
        assertThat(cr).isInstanceOf(DeleteRequest.class);

        cr = reader.readChangeRecord();
        assertThat(cr.getName().toString()).isEqualTo("uid=scarter,ou=People,dc=example,dc=com");
        assertThat(cr).isInstanceOf(AddRequest.class);
        assertThat(((AddRequest) cr).getAttributeCount()).isEqualTo(1);
        assertThat(((AddRequest) cr).getAttribute("cn").firstValueAsString()).isEqualTo(
                "Samantha Carter");
        reader.close();
        target.close();
    }

    /**
     * Testing the diff : entry in target not in source. The rdn of the
     * following example is completed by ou=People.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifDiffEntriesEntryInTargetNotInSource() throws Exception {

        // @formatter:off
        final LDIFEntryReader source = new LDIFEntryReader(
            "dn: uid=scarter,dc=example,dc=com",
            "cn: Samantha Carter"
        );

        final LDIFEntryReader target = new LDIFEntryReader(
            "dn: uid=scarter,ou=People,dc=example,dc=com",
            "cn: Samantha Carter"
        );
        // @formatter:on

        final ChangeRecordReader reader = LDIF.diff(source, target);

        // @formatter:off
        /* output is :
        dn: uid=scarter,ou=People,dc=example,dc=com
        changetype: add
        cn: Samantha Carter

        dn: uid=scarter,dc=example,dc=com
        changetype: delete
         */
        // @formatter:on

        ChangeRecord cr = reader.readChangeRecord();
        assertThat(cr.getName().toString()).isEqualTo("uid=scarter,ou=People,dc=example,dc=com");
        assertThat(cr).isInstanceOf(AddRequest.class);
        assertThat(((AddRequest) cr).getAttributeCount()).isEqualTo(1);
        assertThat(((AddRequest) cr).getAttribute("cn").firstValueAsString()).isEqualTo(
                "Samantha Carter");

        cr = reader.readChangeRecord();
        assertThat(cr.getName().toString()).isEqualTo("uid=scarter,dc=example,dc=com");
        assertThat(cr).isInstanceOf(DeleteRequest.class);

        reader.close();
        source.close();
        target.close();
    }

    /**
     * Diff between two same entries : no modifications expected.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifDiffEntriesNoDiff() throws Exception {

        // @formatter:off
        final LDIFEntryReader source = new LDIFEntryReader(
            "dn: uid=scarter,ou=People,dc=example,dc=com",
            "cn: Samantha Carter"
        );

        final LDIFEntryReader target = new LDIFEntryReader(
            "dn: uid=scarter,ou=People,dc=example,dc=com",
            "cn: Samantha Carter"
        );
        // @formatter:on

        final ChangeRecordReader reader = LDIF.diff(source, target);
        assertThat(reader.hasNext()).isTrue();
        final ChangeRecord cr = reader.readChangeRecord();
        assertThat(cr.getName().toString()).isEqualTo("uid=scarter,ou=People,dc=example,dc=com");
        assertThat(cr instanceof ModifyRequest);
        assertThat(((ModifyRequest) cr).getModifications()).isEmpty();
        reader.close();
        target.close();
    }

    /**
     * Diff between two same entries : no modifications expected.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifDiffEntriesNoDiffBase64() throws Exception {

        // @formatter:off
        final LDIFEntryReader source = new LDIFEntryReader(
            "dn: uid=scarter,ou=People,dc=example,dc=com",
            "cn: Samantha Carter"
        );

        final LDIFEntryReader target = new LDIFEntryReader(
            "dn:: dWlkPXNjYXJ0ZXIsb3U9UGVvcGxlLGRjPWV4YW1wbGUsZGM9Y29t",
            "cn: Samantha Carter"
        );
        // @formatter:on

        final ChangeRecordReader reader = LDIF.diff(source, target);
        assertThat(reader.hasNext()).isTrue();
        final ChangeRecord cr = reader.readChangeRecord();
        assertThat(cr.getName().toString()).isEqualTo("uid=scarter,ou=People,dc=example,dc=com");
        assertThat(cr instanceof ModifyRequest);
        assertThat(((ModifyRequest) cr).getModifications()).isEmpty();
        reader.close();
        target.close();
    }

    /**
     * The diff function doesn't allow malformed ldif. Exception expected.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = DecodeException.class)
    public final void testLdifDiffEntriesNoDiffMalformedTarget() throws Exception {

        final LDIFEntryReader source =
                new LDIFEntryReader("dn: uid=scarter,ou=People,dc=example,dc=com");

        final LDIFEntryReader target = new LDIFEntryReader("dn: wrongRDN");

        LDIF.diff(source, target);
    }

    /**
     * LDIF diff - EntryReader/Writer doesn't allow null. Exception expected.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifDiffEntriesDoesntAllowNull() throws Exception {
        LDIF.diff(null, null);
    }

    /**
     * Test the patch function. Apply simple patch to replace/add data to the
     * input.
     *
     * @throws Exception
     */
    @Test()
    public final void testLdifPatch() throws Exception {
        // @formatter:off
        final LDIFEntryReader input = new LDIFEntryReader(
            "dn: uid=scarter,ou=People,dc=example,dc=com",
            "objectClass: person",
            "sn: new user",
            "mail: mail@mailme.org"
        );

        // @formatter:off
        final  LDIFChangeRecordReader patch = new LDIFChangeRecordReader(
                "dn: uid=scarter,ou=People,dc=example,dc=com",
                "changetype: modify",
                "replace:sn",
                "sn: scarter",
                "-",
                "add: manager",
                "manager: uid=joneill,ou=People,dc=example,dc=com"
        );
        // @formatter:on

        // @formatter:on
        final EntryReader reader = LDIF.patch(input, patch);
        Entry entry = reader.readEntry();
        assertThat(entry.getName().toString()).isEqualTo("uid=scarter,ou=People,dc=example,dc=com");
        assertThat(entry.getAttributeCount()).isEqualTo(4); // objectclass - sn - mail - manager
        assertThat(entry.getAttribute("manager").firstValueAsString()).isEqualTo(
                "uid=joneill,ou=People,dc=example,dc=com");
        reader.close();
    }

    /**
     * LDIF patch - EntryReader/ChangeRecordReader doesn't allow null. Exception
     * expected.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public final void testLdifPatchDoesntAllowNull() throws Exception {
        LDIF.patch(null, null);
    }

}