Fix OPENDJ-588: LDIFEntryWriter contains unused setSchema

Violette Roche-Montane

10.40.2012 1fdc2b972a97f41606a3960a6fcde3a6020396f4

Fix OPENDJ-588: LDIFEntryWriter contains unused setSchema

 opendj3/opendj-ldap-sdk/src/main/java/org/forgerock/opendj/ldif/AbstractLDIFWriter.java

@@ -37,7 +37,6 @@
import org.forgerock.opendj.ldap.ByteSequence;
import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.opendj.ldap.controls.Control;
import org.forgerock.opendj.ldap.schema.Schema;

import com.forgerock.opendj.util.Validator;

@@ -203,8 +202,6 @@

    private final StringBuilder builder = new StringBuilder(80);

    Schema schema = Schema.getDefaultSchema();

    /**
     * Creates a new LDIF entry writer which will append lines of LDIF to the
     * provided list.

 opendj3/opendj-ldap-sdk/src/main/java/org/forgerock/opendj/ldif/LDIFChangeRecordWriter.java

@@ -41,7 +41,6 @@
import org.forgerock.opendj.ldap.requests.DeleteRequest;
import org.forgerock.opendj.ldap.requests.ModifyDNRequest;
import org.forgerock.opendj.ldap.requests.ModifyRequest;
import org.forgerock.opendj.ldap.schema.Schema;

import com.forgerock.opendj.util.Validator;

@@ -197,21 +196,6 @@
    }

    /**
     * Sets the schema which should be used when filtering change records (not
     * required if no filtering is to be performed). The default schema is used
     * if no other is specified.
     *
     * @param schema
     *            The schema which should be used when filtering change records.
     * @return A reference to this {@code LDIFChangeRecordWriter}.
     */
    public LDIFChangeRecordWriter setSchema(final Schema schema) {
        Validator.ensureNotNull(schema);
        this.schema = schema;
        return this;
    }

    /**
     * Specifies the column at which long lines should be wrapped. A value less
     * than or equal to zero (the default) indicates that no wrapping should be
     * performed.

 opendj3/opendj-ldap-sdk/src/main/java/org/forgerock/opendj/ldif/LDIFEntryWriter.java

@@ -37,7 +37,6 @@
import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.ldap.Entry;
import org.forgerock.opendj.ldap.Matcher;
import org.forgerock.opendj.ldap.schema.Schema;

import com.forgerock.opendj.util.Validator;

@@ -220,21 +219,6 @@
    }

    /**
     * Sets the schema which should be used when filtering entries (not required
     * if no filtering is to be performed). The default schema is used if no
     * other is specified.
     *
     * @param schema
     *            The schema which should be used when filtering entries.
     * @return A reference to this {@code LDIFEntryWriter}.
     */
    public LDIFEntryWriter setSchema(final Schema schema) {
        Validator.ensureNotNull(schema);
        this.schema = schema;
        return this;
    }

    /**
     * Specifies the column at which long lines should be wrapped. A value less
     * than or equal to zero (the default) indicates that no wrapping should be
     * performed.

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

@@ -22,17 +22,26 @@
 *
 *
 *      Copyright 2009-2010 Sun Microsystems, Inc.
 *      Portions copyright 2012 ForgeRock AS.
 */

package org.forgerock.opendj.ldif;

import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

import org.forgerock.opendj.ldap.AttributeDescription;
import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.ldap.Entry;
import org.forgerock.opendj.ldap.Filter;
import org.forgerock.opendj.ldap.LinkedHashMapEntry;
import org.forgerock.opendj.ldap.Matcher;
import org.testng.Assert;
import org.testng.annotations.Test;
import static org.fest.assertions.Assertions.assertThat;
import static org.mockito.Mockito.*;

/**
 * This class tests the LDIFEntryWriter functionality.
@@ -40,6 +49,686 @@
public final class LDIFEntryWriterTestCase extends LDIFTestCase {

    /**
     * Standard entry used for the following tests.
     *
     * @return an Entry with pre-defined attributes
     */
    private static final Entry getStandardEntry() {
        final Entry entry = new LinkedHashMapEntry("cn=John Doe,ou=people,dc=example,dc=com");
        entry.addAttribute("objectClass", "top", "person", "inetOrgPerson");
        entry.addAttribute("cn", "John Doe");
        entry.addAttribute("sn", "Doe");
        entry.addAttribute("age", "29");
        entry.addAttribute("givenName", "John");
        entry.addAttribute("description", "one two", "three four",
                "This is a very very long description, Neque porro quisquam est qui dolorem ipsum"
                        + "quia dolor sit amet, consectetur, adipisci velit...");
        entry.addAttribute("typeOnly");
        entry.addAttribute("mail", "email@example.com");
        entry.addAttribute("localized;lang-fr", "\u00e7edilla");
        entry.addAttribute("entryUUID", "ad55a34a-763f-358f-93f9-da86f9ecd9e4");
        entry.addAttribute("entryDN", "uid=bjensen,ou=people,dc=example,dc=com");
        return entry;
    }

    /**
     * Test setExcludeAttribute method of LDIFEntryWriter Throws a
     * NullPointerException if the attributeDescription is null.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public void testSetExcludeAttributeDoesntAllowNull() throws Exception {

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

        writer.setExcludeAttribute(null);
        writer.close();
    }

    /**
     * Test to write an entry with attribute exclusions.
     *
     * @throws Exception
     */
    @Test
    public void testSetExcludeAttributeWithMatch() throws Exception {
        final AttributeDescription attribute = AttributeDescription.valueOf("cn");
        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);

        writer.setExcludeAttribute(attribute);

        writer.writeEntry(getStandardEntry());
        writer.close();

        assertThat(actual.size()).isGreaterThan(0);
        for (String line : actual) {
            // we have excluded this attribute especially
            assertThat(line).doesNotContain("cn: John Doe");
        }
    }

    /**
     * Test to write an entry with attribute exclusions. In this test, the
     * attribute description 'vip' doesn't exist then the entry must be written
     *
     * @throws Exception
     */
    @Test
    public void testSetExcludeAttributeWithNoMatch() throws Exception {
        final AttributeDescription attribute = AttributeDescription.valueOf("vip");
        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);

        writer.setExcludeAttribute(attribute);

        writer.writeEntry(getStandardEntry());
        writer.close();

        assertThat(actual.size()).isGreaterThan(0);
        for (String line : actual) {
            // we have excluded this attribute especially
            assertThat(line).doesNotContain("vip");
        }
        assertThat(actual.size()).isGreaterThan(getStandardEntry().getAttributeCount());
    }

    /**
     * Test SetExcludeBranch method of LDIFEntryWriter Throws a
     * NullPointerException if the excludeBranch is null.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public void testSetExcludeBranchDoesntAllowNull() throws Exception {

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

        writer.setExcludeBranch(null);
        writer.close();
    }

    /**
     * Test SetExcludeBranch method of LDIFEntryWriter.
     *
     * @throws Exception
     */
    @Test
    public void testSetExcludeBranchWrongDN() throws Exception {

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

        DN dn = DN.valueOf("dc=example.com");

        writer.setExcludeBranch(dn);
        writer.writeEntry(getStandardEntry());
        writer.flush();
        writer.close();
        // Even if DN is wrong then entry is expected
        assertThat(actual.size()).isGreaterThan(getStandardEntry().getAttributeCount());

    }

    /**
     * Test SetExcludeBranch method of LDIFEntryWriter.
     *
     * @throws Exception
     */
    @Test
    public void testSetExcludeBranchWithNoMatch() throws Exception {

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

        DN dn = DN.valueOf("dc=example,dc=com");

        writer.setExcludeBranch(dn);
        writer.writeEntry(getStandardEntry());
        writer.flush();
        writer.close();
        // No values expected - we have excluded the branch
        Assert.assertFalse(actual.size() > 0);
    }

    /**
     * Test SetExcludeBranch method of LDIFEntryWriter.
     *
     * @throws Exception
     */
    @Test
    public void testSetExcludeBranchWithMatch() throws Exception {

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

        DN dn = DN.valueOf("dc=example,dc=org");

        writer.setExcludeBranch(dn);
        writer.writeEntry(getStandardEntry());
        writer.flush();
        writer.close();
        // The entry must be written
        assertThat(actual.size()).isGreaterThan(getStandardEntry().getAttributeCount());
    }

    /**
     * Test SetExcludeFilter method of LDIFEntryWriter Throws a
     * NullPointerException if the excludeFilter is null.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public void testsetExcludeFilterDoesntAllowNull() throws Exception {

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

        writer.setExcludeFilter(null);
        writer.close();
    }

    /**
     * Test testSetExcludeFilter method of LDIFEntryWriter. StandardEntry has an
     * objectclass : person
     *
     * @throws Exception
     */
    @Test
    public void testSetExcludeFilterWithMatch() throws Exception {

        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        final Filter filter = Filter.equality("objectclass", "vip");
        final Matcher excludeFilter = filter.matcher();

        writer.setExcludeFilter(excludeFilter);
        writer.writeEntry(getStandardEntry());
        writer.close();

        // objectclass is 'person' in the example, result must be > 0
        assertThat(actual.get(0)).isEqualTo("dn: " + getStandardEntry().getName().toString());
        assertThat(actual.size()).isGreaterThan(getStandardEntry().getAttributeCount());
    }

    /**
     * Test testSetExcludeFilter method of LDIFEntryWriter StandardEntry has an
     * objectclass : person
     *
     * @throws Exception
     */
    @Test
    public void testSetExcludeFilterWithNoMatch() throws Exception {

        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        final Filter filter = Filter.equality("objectclass", "person");
        final Matcher excludeFilter = filter.matcher();

        writer.setExcludeFilter(excludeFilter);
        writer.writeEntry(getStandardEntry());
        writer.close();

        // the entry correspond to the filter - must be excluded
        assertThat(actual).isEmpty();
    }

    /**
     * Test SetIncludeAttribute method of LDIFEntryWriter Throws a
     * NullPointerException if the attributeDescription is null.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public void testSetIncludeAttributeDoesntAllowNull() throws Exception {
        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        writer.setIncludeAttribute(null);
        writer.close();
    }

    /**
     * Test SetIncludeAttribute method of LDIFEntryWriter. Inserting attribute
     * cn (common name) & sn (surname)
     *
     * @throws Exception
     */
    @Test
    public void testSetIncludeAttributeWithMatch() throws Exception {
        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        writer.setIncludeAttribute(AttributeDescription.valueOf("cn"));
        writer.setIncludeAttribute(AttributeDescription.valueOf("sn"));
        writer.writeEntry(getStandardEntry());
        writer.close();

        assertThat(actual.get(0)).isEqualTo("dn: " + getStandardEntry().getName().toString());
        assertThat(actual.get(1)).contains("cn: ");
        assertThat(actual.get(2)).contains("sn: ");
    }

    /**
     * Test SetIncludeAttribute method of LDIFEntryWriter in this example, the
     * field "manager" is not present in the StandardEntry. Then the entry must
     * only write the first line : dn: cn=John Doe,ou=people,dc=example,dc=com
     *
     * @throws Exception
     */
    @Test
    public void testSetIncludeAttributeWithNoMatch() throws Exception {
        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        writer.setIncludeAttribute(AttributeDescription.valueOf("manager"));
        writer.writeEntry(getStandardEntry());
        writer.close();

        // 1st line is containing DN
        assertThat(actual.get(0)).isEqualTo("dn: " + getStandardEntry().getName().toString());
        // empty second
        assertThat(actual.get(1)).isEmpty();
        // verifying no more than 2 lines written
        assertThat(actual.size()).isLessThanOrEqualTo(2);
    }

    /**
     * Test SetIncludeAttribute method of LDIFEntryWriter. Attempted insertions
     * repeating attributes. An attribute mustn't be written twice or +.
     *
     * @throws Exception
     */
    @Test
    public void testSetIncludeAttributeWithRepeatedAttributes() throws Exception {

        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        writer.setIncludeAttribute(AttributeDescription.valueOf("cn"));
        writer.setIncludeAttribute(AttributeDescription.valueOf("sn"));
        writer.setIncludeAttribute(AttributeDescription.valueOf("cn"));
        writer.setIncludeAttribute(AttributeDescription.valueOf("cn"));
        writer.writeEntry(getStandardEntry());
        writer.close();

        assertThat(actual.get(0)).isEqualTo("dn: " + getStandardEntry().getName().toString());
        assertThat(actual.get(1)).contains("cn: ");
        assertThat(actual.get(2)).contains("sn: ");
        // 3 lines of result + 1 empty line
        assertThat(actual.size()).isLessThanOrEqualTo(4);
    }

    /**
     * Test to write an entry excluding all operational attributes
     * setExcludeAllOperationalAttributes to false (default case)
     *
     * @throws Exception
     */
    @Test
    public void testSetExcludeAllOperationalAttributesFalse() throws Exception {

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

        writer.setExcludeAllOperationalAttributes(false);
        writer.writeEntry(getStandardEntry());
        writer.close();

        assertThat(actual.get(0)).isEqualTo("dn: " + getStandardEntry().getName().toString());
        assertThat(actual.size()).isGreaterThan(getStandardEntry().getAttributeCount());
    }

    /**
     * Test to write an entry excluding all operational attributes
     * setExcludeAllOperationalAttributes is forced to true Result should be dn:
     * cn=John Doe,ou=people,dc=example,dc=com plus an empty line.
     *
     * @throws Exception
     */
    @Test
    public void testSetExcludeAllOperationalAttributesTrue() throws Exception {

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

        writer.setExcludeAllOperationalAttributes(true);
        writer.writeEntry(getStandardEntry());
        writer.close();

        for (String line : actual) {
            assertThat(line).doesNotContain("entryUUID");
            // entryDN appears here but it's also an operational attribute - jira/browse/OPENDJ-589
            // TODO when bug will be fixed, test if entryDN appears.
        }

        assertThat(actual.get(0)).isEqualTo("dn: " + getStandardEntry().getName().toString());
        assertThat(actual.size()).isGreaterThan(getStandardEntry().getAttributeCount());
    }

    /**
     * Test to write an entry excluding user attributes Default case - full
     * entry must be written
     *
     * @throws Exception
     */
    @Test
    public void testSetExcludeAllUserAttributesFalse() throws Exception {

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

        writer.setExcludeAllUserAttributes(false);
        writer.writeEntry(getStandardEntry());
        writer.flush();
        writer.close();

        assertThat(actual.get(0)).isEqualTo("dn: " + getStandardEntry().getName().toString());
        assertThat(actual.size()).isGreaterThan(getStandardEntry().getAttributeCount());
    }

    /**
     * Test to write an entry excluding user attributes result should be dn:
     * cn=John Doe,ou=people,dc=example,dc=com plus an empty line.
     *
     * @throws Exception
     */
    @Test
    public void testSetExcludeAllUserAttributesTrue() throws Exception {

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

        writer.setExcludeAllUserAttributes(true);
        writer.writeEntry(getStandardEntry());
        writer.flush();
        writer.close();

        for (String line : actual) {
            assertThat(line).doesNotContain("sn");
            assertThat(line).doesNotContain("mail");
        }
        assertThat(actual.get(0).contains("dn: cn=John Doe,ou=people,dc=example,dc=com"));
        assertThat(actual.size()).isLessThan(getStandardEntry().getAttributeCount());
    }

    /**
     * Test SetIncludeBranch method of LDIFEntryWriter Throws a
     * NullPointerException if the includeBranch is null.
     *
     * @throws Exception
     */
    @Test(expectedExceptions = NullPointerException.class)
    public void testSetIncludeBranchDoesntAllowNull() throws Exception {
        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        writer.setIncludeBranch(null);
        writer.close();
    }

    /**
     * Test SetIncludeBranch method of LDIFEntryWriter verifying right data are
     * present.
     *
     * @throws Exception
     */
    @Test
    public void testSetIncludeBranchWithMatch() throws Exception {
        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);

        DN dn = DN.valueOf("dc=example,dc=com");
        writer.setIncludeBranch(dn);

        writer.writeEntry(getStandardEntry());
        writer.close();

        // Must contains all the attributes
        assertThat(actual.get(0)).contains(getStandardEntry().getName().toString());
        assertThat(actual.size()).isGreaterThan(getStandardEntry().getAttributeCount());
    }

    /**
     * Test SetIncludeBranch method of LDIFEntryWriter DN included is
     * "dc=opendj,dc=org", which is not the one from the standard entry Entry
     * must not be written
     *
     * @throws Exception
     */
    @Test
    public void testSetIncludeBranchWithNoMatch() throws Exception {
        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);

        DN dn = DN.valueOf("dc=opendj,dc=org");
        writer.setIncludeBranch(dn);

        writer.writeEntry(getStandardEntry());
        writer.close();

        // No result expected
        assertThat(actual.size()).isEqualTo(0);
    }

    /**
     * Test SetIncludeFilter method of LDIFEntryWriter. This example use
     * Filter.equality("objectclass", "vip"); which is not the one from the
     * standard entry.
     *
     * @throws Exception
     */
    @Test
    public void testSetIncludeFilterWithNoMatch() throws Exception {

        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        final Filter filter = Filter.equality("objectclass", "vip");
        final Matcher includeFilter = filter.matcher();

        writer.setIncludeFilter(includeFilter);
        writer.writeEntry(getStandardEntry());
        writer.close();

        assertThat(actual.size()).isEqualTo(0);
    }

    /**
     * Test SetIncludeFilter method of LDIFEntryWriter. This example use
     * Filter.equality("objectclass", "person"); which is the one from the
     * standard entry.
     *
     * @throws Exception
     */
    @Test
    public void testSetIncludeFilterWithMatch() throws Exception {

        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        final Filter filter = Filter.equality("objectclass", "person");
        final Matcher includeFilter = filter.matcher();

        writer.setIncludeFilter(includeFilter);
        writer.writeEntry(getStandardEntry());
        writer.close();

        // Entry must be written
        assertThat(actual).isNotNull();
        assertThat(actual.size()).isGreaterThanOrEqualTo(getStandardEntry().getAttributeCount());
    }

    /**
     * Test SetIncludeFilter method of LDIFEntryWriter Throws a
     * NullPointerException if the schema is null.
     *
     * @throws NullPointerException
     */
    @Test(expectedExceptions = NullPointerException.class)
    public void testSetIncludeFilterDoesntAllowNull() throws Exception {
        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        writer.setIncludeFilter(null);
        writer.writeEntry(getStandardEntry());
        writer.close();
    }

    /**
     * Test WriteComment method of LDIFEntryWriter using the wrap function.
     *
     * @throws Exception
     *             If the test failed unexpectedly.
     */
    @Test()
    public void testWriteCommentUsingTheWrapFunction() throws Exception {

        final CharSequence comment = "Lorem ipsum dolor sit amet, consectetur adipisicing elit";

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

        int wrapColumn = 15;
        writer.setWrapColumn(wrapColumn);
        writer.writeComment(comment);
        writer.close();

        for (String line : actual) {
            // The line length <= writer.wrapColumn
            assertThat(line.length()).isLessThanOrEqualTo(wrapColumn);
            // Each line started with #
            assertThat(line.startsWith("#")).isTrue();
        }
    }

    /**
     * Test WriteComment method of LDIFEntryWriter using the wrap function. set
     * wrap to 0.
     *
     * @throws Exception
     *             If the test failed unexpectedly.
     */
    @Test()
    public void testWriteCommentUsingTheWrapFunctionShortComment() throws Exception {

        final CharSequence comment = "Lorem ipsum dolor";

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

        int wrapColumn = 30;
        writer.setWrapColumn(wrapColumn);
        writer.writeComment(comment);
        writer.close();

        for (String line : actual) {
            // Each line started with #
            assertThat(line.startsWith("#")).isTrue();
            assertThat(line.length()).isLessThanOrEqualTo(wrapColumn);
        }
    }

    /**
     * Test WriteComment method of LDIFEntryWriter using the wrap function. The
     * comment doesn't contain any empty spaces.
     *
     * @throws Exception
     *             If the test failed unexpectedly.
     */
    @Test()
    public void testWriteCommentUsingTheWrapFunctionNoEmptySpace() throws Exception {

        final CharSequence comment = "Lorem ipsumdolorsitamet,consecteturadipisicingelit";

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

        int wrapColumn = 15;
        writer.setWrapColumn(wrapColumn);
        writer.writeComment(comment);
        writer.close();

        for (String line : actual) {
            // The line length <= writer.wrapColumn
            assertThat(line.length()).isLessThanOrEqualTo(wrapColumn);
            // Each line started with #
            assertThat(line.startsWith("#")).isTrue();
        }
    }

    /**
     * Test WriteComment method of LDIFEntryWriter.
     *
     * @throws Exception
     *             If the test failed unexpectedly.
     */
    @Test()
    public void testWriteComment() throws Exception {

        final CharSequence comment1 = "This is a new comment";
        final CharSequence comment2 = "Another one";

        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        writer.writeComment(comment1);
        writer.writeComment(comment2);
        writer.close();

        // Verifying comments are well written in the LDIF Entry
        Assert.assertEquals(actual.size(), 2);
        assertThat(actual.get(0)).isEqualTo("# " + comment1);
        assertThat(actual.get(1)).isEqualTo("# " + comment2);
    }

    /**
     * Test to write an entry adding the user friendly Comment TODO
     *
     * @throws Exception
     */
    @Test
    public void testSetAddUserFriendlyComments() throws IOException {
        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);

        final CharSequence comment = "A simple comment";

        writer.setAddUserFriendlyComments(true);
        writer.writeComment0(comment);
        writer.close();

        // TODO Add a test when the function will be implemented in AbstractLDIFWriter

    }

    /**
     * Tests writeEntry method of LDIFEntryWriter class. Using the
     * getStandardEntry. Attribute description tested, containing a long text.
     * Wrap need to be used is this case.
     *
     * @throws Exception
     *             If the test failed unexpectedly.
     */
    @Test()
    public void testWriteEntryUsingStandardEntry() throws Exception {

        final List<String> actual = new ArrayList<String>();
        final LDIFEntryWriter writer = new LDIFEntryWriter(actual);
        final int wrapColumn = 15;
        writer.setWrapColumn(wrapColumn);
        writer.writeEntry(getStandardEntry());
        writer.close();

        int countDesc = 0;

        // Entry must be written - check wrap on description
        assertThat(actual).isNotNull();
        for (String line : actual) {
            if (line.contains("description")) {
                countDesc++;
            }
            assertThat(line.length()).isLessThanOrEqualTo(wrapColumn);
        }
        assertThat(countDesc).isEqualTo(getStandardEntry().getAttribute("description").size());
        assertThat(actual.size()).isGreaterThanOrEqualTo(getStandardEntry().getAttributeCount());
    }

    /**
     * Tests writeEntry method of LDIFEntryWriter class.See
     * https://opends.dev.java.net/issues/show_bug.cgi?id=4545 for more details.
     *
@@ -73,4 +762,63 @@
            Assert.assertEquals(actual.get(i), expected[i], "LDIF output was " + actual);
        }
    }

    /**
     * Testing the WriteEntry function using the mock for testing more
     * IOExceptions and verify if they are correctly handled.
     *
     * @throws FileNotFoundException
     * @throws Exception
     */
    @Test(expectedExceptions = IOException.class)
    public void testWriteEntryUsingMockOutputThrowsIOException() throws Exception {

        OutputStream mockOutput = mock(OutputStream.class);
        doThrow(new IOException()).when(mockOutput).write(any(byte[].class));
        doThrow(new IOException()).when(mockOutput).write(any(byte[].class), anyInt(), anyInt());

        LDIFEntryWriter writer = new LDIFEntryWriter(mockOutput);
        try {
            CharSequence comment = "This is a new comment";
            writer.writeComment(comment);
        } finally {
            writer.close();
        }
    }

    /**
     * Verify flush/close are also forwarded to the stream.
     *
     * @throws Exception
     */
    @Test
    public void testWriteEntryUsingMockOutputForFlushAndClose() throws Exception {
        OutputStream mockOutput = mock(OutputStream.class);
        LDIFEntryWriter writer = new LDIFEntryWriter(mockOutput);
        try {
            writer.flush();
            writer.flush();
            verify(mockOutput, times(2)).flush();
        } finally {
            writer.close();
            verify(mockOutput, times(1)).close();
        }
    }

    /**
     * Test the WriteEntry using an output file verifying write is correctly
     * invoked.
     *
     * @throws Exception
     */
    @Test
    public void testWriteEntryOutputStreamUsingMock() throws Exception {
        final OutputStream out = mock(OutputStream.class);
        final LDIFEntryWriter writer = new LDIFEntryWriter(out);

        writer.writeEntry(getStandardEntry());
        writer.close();

        verify(out, times(1)).write(any(byte[].class), anyInt(), anyInt());
    }
}