directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From elecha...@apache.org
Subject svn commit: r1178423 [1/2] - /directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/
Date Mon, 03 Oct 2011 14:59:19 GMT
Author: elecharny
Date: Mon Oct  3 14:59:19 2011
New Revision: 1178423

URL: http://svn.apache.org/viewvc?rev=1178423&view=rev
Log:
Readded the Netscape SDK tests in a dedicated package

Added:
    directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/
    directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/AddIT.java
    directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/BindIT.java
    directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/CompareIT.java
    directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/DeleteIT.java
    directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/IllegalModificationIT.java
    directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/ModifyDnReferralIT.java
    directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/ModifyReferralIT.java

Added: directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/AddIT.java
URL: http://svn.apache.org/viewvc/directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/AddIT.java?rev=1178423&view=auto
==============================================================================
--- directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/AddIT.java (added)
+++ directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/AddIT.java Mon Oct  3 14:59:19 2011
@@ -0,0 +1,1494 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *  
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *  
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License. 
+ *  
+ */
+package org.apache.directory.server.operations.ldapsdk;
+
+
+import static org.apache.directory.server.integ.ServerIntegrationUtils.getAdminConnection;
+import static org.apache.directory.server.integ.ServerIntegrationUtils.getNsdkWiredConnection;
+import static org.apache.directory.server.integ.ServerIntegrationUtils.getWiredContext;
+import static org.apache.directory.server.integ.ServerIntegrationUtils.getWiredContextThrowOnRefferal;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+import javax.naming.Context;
+import javax.naming.NamingEnumeration;
+import javax.naming.NamingException;
+import javax.naming.PartialResultException;
+import javax.naming.ReferralException;
+import javax.naming.directory.Attributes;
+import javax.naming.directory.BasicAttribute;
+import javax.naming.directory.BasicAttributes;
+import javax.naming.directory.DirContext;
+import javax.naming.directory.InvalidAttributeValueException;
+import javax.naming.directory.SchemaViolationException;
+import javax.naming.directory.SearchControls;
+import javax.naming.directory.SearchResult;
+import javax.naming.ldap.LdapContext;
+import javax.naming.ldap.LdapName;
+
+import netscape.ldap.LDAPAttribute;
+import netscape.ldap.LDAPAttributeSet;
+import netscape.ldap.LDAPConnection;
+import netscape.ldap.LDAPConstraints;
+import netscape.ldap.LDAPControl;
+import netscape.ldap.LDAPEntry;
+import netscape.ldap.LDAPException;
+import netscape.ldap.LDAPResponse;
+import netscape.ldap.LDAPResponseListener;
+import netscape.ldap.LDAPSearchConstraints;
+
+import org.apache.directory.ldap.client.api.LdapConnection;
+import org.apache.directory.ldap.client.api.LdapNetworkConnection;
+import org.apache.directory.server.annotations.CreateLdapServer;
+import org.apache.directory.server.annotations.CreateTransport;
+import org.apache.directory.server.constants.ServerDNConstants;
+import org.apache.directory.server.core.CoreSession;
+import org.apache.directory.server.core.DirectoryService;
+import org.apache.directory.server.core.LdapPrincipal;
+import org.apache.directory.server.core.annotations.ApplyLdifs;
+import org.apache.directory.server.core.annotations.ContextEntry;
+import org.apache.directory.server.core.annotations.CreateDS;
+import org.apache.directory.server.core.annotations.CreateIndex;
+import org.apache.directory.server.core.annotations.CreatePartition;
+import org.apache.directory.server.core.integ.AbstractLdapTestUnit;
+import org.apache.directory.server.core.integ.FrameworkRunner;
+import org.apache.directory.server.core.jndi.ServerLdapContext;
+import org.apache.directory.server.integ.ServerIntegrationUtils;
+import org.apache.directory.shared.ldap.model.constants.AuthenticationLevel;
+import org.apache.directory.shared.ldap.model.constants.SchemaConstants;
+import org.apache.directory.shared.ldap.model.csn.Csn;
+import org.apache.directory.shared.ldap.model.csn.CsnFactory;
+import org.apache.directory.shared.ldap.model.entry.Attribute;
+import org.apache.directory.shared.ldap.model.entry.DefaultAttribute;
+import org.apache.directory.shared.ldap.model.entry.DefaultEntry;
+import org.apache.directory.shared.ldap.model.entry.DefaultModification;
+import org.apache.directory.shared.ldap.model.entry.Entry;
+import org.apache.directory.shared.ldap.model.entry.Modification;
+import org.apache.directory.shared.ldap.model.entry.ModificationOperation;
+import org.apache.directory.shared.ldap.model.exception.LdapException;
+import org.apache.directory.shared.ldap.model.exception.LdapNoSuchAttributeException;
+import org.apache.directory.shared.ldap.model.exception.LdapOperationException;
+import org.apache.directory.shared.ldap.model.ldif.LdifUtils;
+import org.apache.directory.shared.ldap.model.message.ResultCodeEnum;
+import org.apache.directory.shared.ldap.model.name.Dn;
+import org.apache.directory.shared.util.Strings;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+/**
+ * Various add scenario tests.
+ * 
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ */
+@RunWith(FrameworkRunner.class)
+@CreateDS(allowAnonAccess = true, name = "AddIT-class", partitions =
+    {
+        @CreatePartition(
+            name = "example",
+            suffix = "dc=example,dc=com",
+            contextEntry = @ContextEntry(
+                entryLdif = "dn: dc=example,dc=com\n" +
+                    "dc: example\n" +
+                    "objectClass: top\n" +
+                    "objectClass: domain\n\n"),
+            indexes =
+            {
+                @CreateIndex(attribute = "objectClass"),
+                @CreateIndex(attribute = "dc"),
+                @CreateIndex(attribute = "ou")
+            }),
+
+        @CreatePartition(
+            name = "directory",
+            suffix = "dc=directory,dc=apache,dc=org",
+            contextEntry = @ContextEntry(
+                entryLdif = "dn: dc=directory,dc=apache,dc=org\n" +
+                    "dc: directory\n" +
+                    "objectClass: top\n" +
+                    "objectClass: domain\n\n"),
+            indexes =
+            {
+                @CreateIndex(attribute = "objectClass"),
+                @CreateIndex(attribute = "dc"),
+                @CreateIndex(attribute = "ou")
+            }) })
+@CreateLdapServer( name = "ADDIT",  transports =
+    { @CreateTransport(protocol = "LDAP", port = -1 ) })
+@ApplyLdifs(
+    {
+        // Entry # 0
+        "dn: cn=The Person,ou=system",
+        "objectClass: person",
+        "objectClass: top",
+        "cn: The Person",
+        "description: this is a person",
+        "sn: Person",
+
+        // Entry # 1
+        "dn: uid=akarasulu,ou=users,ou=system",
+        "objectClass: uidObject",
+        "objectClass: person",
+        "objectClass: top",
+        "uid: akarasulu",
+        "cn: Alex Karasulu",
+        "sn: karasulu",
+
+        // Entry # 2
+        "dn: ou=Computers,uid=akarasulu,ou=users,ou=system",
+        "objectClass: organizationalUnit",
+        "objectClass: top",
+        "ou: computers",
+        "description: Computers for Alex",
+        "seeAlso: ou=Machines,uid=akarasulu,ou=users,ou=system",
+
+        // Entry # 3
+        "dn: uid=akarasuluref,ou=users,ou=system",
+        "objectClass: uidObject",
+        "objectClass: referral",
+        "objectClass: top",
+        "uid: akarasuluref",
+        "ref: ldap://localhost:10389/uid=akarasulu,ou=users,ou=system",
+        "ref: ldap://foo:10389/uid=akarasulu,ou=users,ou=system",
+        "ref: ldap://bar:10389/uid=akarasulu,ou=users,ou=system" })
+public class AddIT extends AbstractLdapTestUnit
+{
+    private static final Logger LOG = LoggerFactory.getLogger( AddIT.class );
+    private static final String RDN = "cn=The Person";
+
+    private static final String BASE = "ou=system";
+    private static final String BASE_EXAMPLE_COM = "dc=example,dc=com";
+    private static final String BASE_DIRECTORY_APACHE_ORG = "dc=directory,dc=apache,dc=org";
+
+
+    /**
+     * This is the original defect as in JIRA DIREVE-216.
+     * 
+     * @throws NamingException if we cannot connect and perform add operations
+     */
+    @Test
+    public void testAddObjectClasses() throws Exception
+    {
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        // modify object classes, add two more
+        Attributes attributes = LdifUtils.createJndiAttributes( "objectClass: organizationalPerson",
+                "objectClass: inetOrgPerson" );
+
+        DirContext person = ( DirContext ) ctx.lookup( RDN );
+        person.modifyAttributes( "", DirContext.ADD_ATTRIBUTE, attributes );
+
+        // Read again from directory
+        person = ( DirContext ) ctx.lookup( RDN );
+        attributes = person.getAttributes( "" );
+        javax.naming.directory.Attribute newOcls = attributes.get( "objectClass" );
+
+        String[] expectedOcls =
+            { "top", "person", "organizationalPerson", "inetOrgPerson" };
+
+        for ( String name : expectedOcls )
+        {
+            assertTrue( "object class " + name + " is present", newOcls.contains( name ) );
+        }
+    }
+
+
+    /**
+     * This changes a single attribute value. Just as a reference.
+     * 
+     * @throws NamingException if we cannot connect and modify the description
+     */
+    @Test
+    public void testModifyDescription() throws Exception
+    {
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        String newDescription = "More info on the user ...";
+
+        // modify object classes, add two more
+        Attributes attributes = new BasicAttributes( true );
+        javax.naming.directory.Attribute desc = new BasicAttribute( "description", newDescription );
+        attributes.put( desc );
+
+        DirContext person = ( DirContext ) ctx.lookup( RDN );
+        person.modifyAttributes( "", DirContext.REPLACE_ATTRIBUTE, attributes );
+
+        // Read again from directory
+        person = ( DirContext ) ctx.lookup( RDN );
+        attributes = person.getAttributes( "" );
+        javax.naming.directory.Attribute newDesc = attributes.get( "description" );
+
+        assertTrue( "new Description", newDesc.contains( newDescription ) );
+    }
+
+
+    /**
+     * Try to add entry with required attribute missing.
+     * 
+     * @throws NamingException if we fail to connect
+     */
+    @Test
+    public void testAddWithMissingRequiredAttributes() throws Exception
+    {
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        // person without sn
+        Attributes attrs = new BasicAttributes( true );
+        javax.naming.directory.Attribute ocls = new BasicAttribute( "objectClass" );
+        ocls.add( "top" );
+        ocls.add( "person" );
+        attrs.put( ocls );
+        attrs.put( "cn", "Fiona Apple" );
+
+        try
+        {
+            ctx.createSubcontext( "cn=Fiona Apple", attrs );
+            fail( "creation of entry should fail" );
+        }
+        catch ( SchemaViolationException e )
+        {
+            // expected
+        }
+    }
+
+
+    /**
+     * Test case to demonstrate DIRSERVER-643 ("Netscape SDK: Adding an entry with
+     * two description attributes does not combine values."). Uses Sun ONE Directory
+     * SDK for Java 4.1 , or comparable (Netscape, Mozilla).
+     * 
+     * @throws LDAPException if we fail to connect and add entries
+     */
+    @Test
+    public void testAddEntryWithTwoDescriptions() throws Exception
+    {
+        LdapConnection con = getAdminConnection( getLdapServer() );
+
+        String dn = "cn=Kate Bush," + BASE;
+        Entry kate = new DefaultEntry( dn );
+
+        kate.add( "objectclass", "top", "person" );
+        kate.add( "sn", "Bush" );
+        kate.add( "cn", "Kate Bush" );
+
+        String descr[] =
+            { "a British singer-songwriter with an expressive four-octave voice",
+                "one of the most influential female artists of the twentieth century" };
+
+        kate.add( "description", descr );
+
+        con.add( kate );
+
+        // Analyze entry and description attribute
+        Entry kateReloaded = con.lookup( dn );
+        assertNotNull( kateReloaded );
+        Attribute attr = kateReloaded.get( "description" );
+        assertNotNull( attr );
+        assertEquals( 2, attr.size() );
+
+        // Remove entry
+        con.delete( dn );
+        con.unBind();
+    }
+
+
+    /**
+     * Testcase to demonstrate DIRSERVER-643 ("Netscape SDK: Adding an entry with
+     * two description attributes does not combine values."). Uses Sun ONE Directory
+     * SDK for Java 4.1 , or comparable (Netscape, Mozilla).
+     * 
+     * @throws LDAPException if we fail to connect and add entries
+     */
+    @Test
+    public void testAddEntryWithTwoDescriptionsVariant() throws Exception
+    {
+        LdapConnection con = getAdminConnection( getLdapServer() );
+
+        String dn = "cn=Kate Bush," + BASE;
+        Entry kate = new DefaultEntry( dn );
+        kate.add( "objectclass", "top", "person" );
+        kate.add( "sn", "Bush" );
+        kate.add( "cn", "Kate Bush" );
+
+        String descr[] =
+            { "a British singer-songwriter with an expressive four-octave voice",
+                "one of the most influential female artists of the twentieth century" };
+
+        kate.add( "description", descr[0] );
+        kate.add( "description", descr[1] );
+
+        con.add( kate );
+
+        // Analyze entry and description attribute
+        Entry kateReloaded = con.lookup( dn );
+        assertNotNull( kateReloaded );
+        Attribute attr = kateReloaded.get( "description" );
+        assertNotNull( attr );
+        assertEquals( 2, attr.size() );
+
+        // Remove entry
+        con.delete( dn );
+        con.unBind();
+    }
+
+
+    /**
+     * Testcase to demonstrate DIRSERVER-643 ("Netscape SDK: Adding an entry with
+     * two description attributes does not combine values."). Uses Sun ONE Directory
+     * SDK for Java 4.1 , or comparable (Netscape, Mozilla).
+     * 
+     * @throws LDAPException if we fail to connect and add entries
+     */
+    @Test
+    public void testAddEntryWithTwoDescriptionsSecondVariant() throws Exception
+    {
+        LdapConnection con = getAdminConnection( getLdapServer() );
+
+        String dn = "cn=Kate Bush," + BASE;
+        Entry kate = new DefaultEntry( dn );
+
+        kate.add( "objectclass", "top", "person" );
+        kate.add( "sn", "Bush" );
+
+        String descr[] =
+            { "a British singer-songwriter with an expressive four-octave voice",
+                "one of the most influential female artists of the twentieth century" };
+
+        kate.add( "description", descr[0] );
+        kate.add( "cn", "Kate Bush" );
+        kate.add( "description", descr[1] );
+
+        con.add( kate );
+
+        // Analyze entry and description attribute
+        Entry kateReloaded = con.lookup( dn );
+        assertNotNull( kateReloaded );
+        Attribute attr = kateReloaded.get( "description" );
+        assertNotNull( attr );
+        assertEquals( 2, attr.size() );
+
+        // Remove entry
+        con.delete( dn );
+        con.unBind();
+    }
+
+
+    /**
+     * Try to add entry with invalid number of values for a single-valued attribute
+     * 
+     * @throws NamingException if we fail to connect and add entries
+     * @see <a href="http://issues.apache.org/jira/browse/DIRSERVER-614">DIRSERVER-614</a>
+     */
+    @Test
+    public void testAddWithInvalidNumberOfAttributeValues() throws Exception
+    {
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        // add inetOrgPerson with two displayNames
+        Attributes attrs = new BasicAttributes( true );
+        javax.naming.directory.Attribute ocls = new BasicAttribute( "objectClass" );
+        ocls.add( "top" );
+        ocls.add( "inetOrgPerson" );
+        attrs.put( ocls );
+        attrs.put( "cn", "Fiona Apple" );
+        attrs.put( "sn", "Apple" );
+        javax.naming.directory.Attribute displayName = new BasicAttribute( "displayName" );
+        displayName.add( "Fiona" );
+        displayName.add( "Fiona A." );
+        attrs.put( displayName );
+
+        try
+        {
+            ctx.createSubcontext( "cn=Fiona Apple", attrs );
+            fail( "creation of entry should fail" );
+        }
+        catch ( InvalidAttributeValueException e )
+        {
+        }
+    }
+
+
+    /**
+     * Try to add entry and an alias to it. Afterwards, remove it.
+     * 
+     * @throws NamingException if we fail to connect and add entries
+     */
+    @Test
+    public void testAddAlias() throws Exception
+    {
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        // Create entry
+        Attributes entry = new BasicAttributes( true );
+        javax.naming.directory.Attribute entryOcls = new BasicAttribute( SchemaConstants.OBJECT_CLASS_AT );
+        entryOcls.add( SchemaConstants.TOP_OC );
+        entryOcls.add( SchemaConstants.ORGANIZATIONAL_UNIT_OC );
+        entry.put( entryOcls );
+        entry.put( SchemaConstants.OU_AT, "favorite" );
+        String entryRdn = "ou=favorite";
+        ctx.createSubcontext( entryRdn, entry );
+
+        // Create Alias
+        String aliasedObjectName = entryRdn + "," + ctx.getNameInNamespace();
+        Attributes alias = new BasicAttributes( true );
+        javax.naming.directory.Attribute aliasOcls = new BasicAttribute( SchemaConstants.OBJECT_CLASS_AT );
+        aliasOcls.add( SchemaConstants.TOP_OC );
+        aliasOcls.add( SchemaConstants.EXTENSIBLE_OBJECT_OC );
+        aliasOcls.add( SchemaConstants.ALIAS_OC );
+        alias.put( aliasOcls );
+        alias.put( SchemaConstants.OU_AT, "bestFruit" );
+        alias.put( SchemaConstants.ALIASED_OBJECT_NAME_AT, aliasedObjectName );
+        String rdnAlias = "ou=bestFruit";
+        ctx.createSubcontext( rdnAlias, alias );
+
+        // Remove alias and entry
+        ctx.destroySubcontext( rdnAlias );
+        ctx.destroySubcontext( entryRdn );
+    }
+
+
+    /**
+     * Try to add entry and an alias to it. Afterwards, remove it. This version
+     * cretes a container entry before the operations.
+     * 
+     * @throws NamingException if we fail to connect and add entries
+     */
+    @Test
+    public void testAddAliasInContainer() throws Exception
+    {
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        // Create container
+        Attributes container = new BasicAttributes( true );
+        javax.naming.directory.Attribute containerOcls = new BasicAttribute( SchemaConstants.OBJECT_CLASS_AT );
+        containerOcls.add( SchemaConstants.TOP_OC );
+        containerOcls.add( SchemaConstants.ORGANIZATIONAL_UNIT_OC );
+        container.put( containerOcls );
+        container.put( SchemaConstants.OU_AT, "Fruits" );
+        String containerRdn = "ou=Fruits";
+        DirContext containerCtx = ctx.createSubcontext( containerRdn, container );
+
+        // Create entry
+        Attributes entry = new BasicAttributes( true );
+        javax.naming.directory.Attribute entryOcls = new BasicAttribute( SchemaConstants.OBJECT_CLASS_AT );
+        entryOcls.add( SchemaConstants.TOP_OC );
+        entryOcls.add( SchemaConstants.ORGANIZATIONAL_UNIT_OC );
+        entry.put( entryOcls );
+        entry.put( SchemaConstants.OU_AT, "favorite" );
+        String entryRdn = "ou=favorite";
+        containerCtx.createSubcontext( entryRdn, entry );
+
+        // Create alias ou=bestFruit,ou=Fruits to entry ou=favorite,ou=Fruits
+        String aliasedObjectName = entryRdn + "," + containerCtx.getNameInNamespace();
+        Attributes alias = new BasicAttributes( true );
+        javax.naming.directory.Attribute aliasOcls = new BasicAttribute( SchemaConstants.OBJECT_CLASS_AT );
+        aliasOcls.add( SchemaConstants.TOP_OC );
+        aliasOcls.add( SchemaConstants.EXTENSIBLE_OBJECT_OC );
+        aliasOcls.add( SchemaConstants.ALIAS_OC );
+        alias.put( aliasOcls );
+        alias.put( SchemaConstants.OU_AT, "bestFruit" );
+        alias.put( SchemaConstants.ALIASED_OBJECT_NAME_AT, aliasedObjectName );
+        String rdnAlias = "ou=bestFruit";
+        containerCtx.createSubcontext( rdnAlias, alias );
+
+        // search one level scope for alias 
+        SearchControls controls = new SearchControls();
+        controls.setDerefLinkFlag( true );
+        controls.setSearchScope( SearchControls.ONELEVEL_SCOPE );
+        containerCtx.addToEnvironment( "java.naming.ldap.derefAliases", "never" );
+        Set<String> names = new HashSet<String>();
+        NamingEnumeration<SearchResult> ne = containerCtx.search( "", "(objectClass=*)", controls );
+        assertTrue( ne.hasMore() );
+        SearchResult sr = ne.next();
+        names.add( sr.getName() );
+        assertTrue( ne.hasMore() );
+        sr = ne.next();
+        names.add( sr.getName() );
+        assertFalse( ne.hasMore() );
+        assertEquals( 2, names.size() );
+        assertTrue( names.contains( "ou=favorite" ) );
+        assertTrue( names.contains( "ou=bestFruit" ) );
+
+        // search one level with dereferencing turned on
+        controls = new SearchControls();
+        controls.setDerefLinkFlag( true );
+        controls.setSearchScope( SearchControls.ONELEVEL_SCOPE );
+        containerCtx.addToEnvironment( "java.naming.ldap.derefAliases", "always" );
+        ne = containerCtx.search( "", "(objectClass=*)", controls );
+        assertTrue( ne.hasMore() );
+        sr = ne.next();
+        assertEquals( "ou=favorite", sr.getName() );
+        assertFalse( ne.hasMore() );
+
+        // search with base set to alias and dereferencing turned on
+        controls = new SearchControls();
+        controls.setDerefLinkFlag( false );
+        controls.setSearchScope( SearchControls.OBJECT_SCOPE );
+        containerCtx.addToEnvironment( "java.naming.ldap.derefAliases", "always" );
+        ne = containerCtx.search( "ou=bestFruit", "(objectClass=*)", controls );
+        assertTrue( ne.hasMore() );
+        sr = ne.next();
+        assertEquals( "ldap://localhost:" + getLdapServer().getPort() + "/ou=favorite,ou=Fruits,ou=system",
+            sr.getName() );
+        assertFalse( ne.hasMore() );
+
+        // Remove alias and entry
+        containerCtx.destroySubcontext( rdnAlias );
+        containerCtx.destroySubcontext( entryRdn );
+
+        // Remove container
+        ctx.destroySubcontext( containerRdn );
+    }
+
+
+    /**
+     * Try to add entry and an alias to it. Afterwards, remove it.  Taken from
+     * DIRSERVER-1157 test contribution.
+     * 
+     * @see https://issues.apache.org/jira/browse/DIRSERVER-1157
+     * @throws Exception
+     */
+    @Test
+    public void testAddDeleteAlias() throws Exception
+    {
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        // Create entry ou=favorite,ou=system
+        Attributes entry = new BasicAttributes( true );
+        javax.naming.directory.Attribute entryOcls = new BasicAttribute( SchemaConstants.OBJECT_CLASS_AT );
+        entryOcls.add( SchemaConstants.TOP_OC );
+        entryOcls.add( SchemaConstants.ORGANIZATIONAL_UNIT_OC );
+        entry.put( entryOcls );
+        entry.put( SchemaConstants.OU_AT, "favorite" );
+        String entryRdn = "ou=favorite";
+        ctx.createSubcontext( entryRdn, entry );
+
+        // Create Alias ou=bestFruit,ou=system to ou=favorite
+        String aliasedObjectName = entryRdn + "," + ctx.getNameInNamespace();
+        Attributes alias = new BasicAttributes( true );
+        javax.naming.directory.Attribute aliasOcls = new BasicAttribute( SchemaConstants.OBJECT_CLASS_AT );
+        aliasOcls.add( SchemaConstants.TOP_OC );
+        aliasOcls.add( SchemaConstants.EXTENSIBLE_OBJECT_OC );
+        aliasOcls.add( SchemaConstants.ALIAS_OC );
+        alias.put( aliasOcls );
+        alias.put( SchemaConstants.OU_AT, "bestFruit" );
+        alias.put( SchemaConstants.ALIASED_OBJECT_NAME_AT, aliasedObjectName );
+        String rdnAlias = "ou=bestFruit";
+        ctx.createSubcontext( rdnAlias, alias );
+
+        // Remove alias and entry
+        ctx.destroySubcontext( rdnAlias ); //Waiting for Connection.reply()
+        ctx.destroySubcontext( entryRdn );
+    }
+
+
+    /**
+     * Test for DIRSERVER-1352:  Infinite Loop when deleting an alias with suffix size > 1
+     * Test for DIRSERVER-1157:  Deleting Alias entry failure
+     * 
+     * @see https://issues.apache.org/jira/browse/DIRSERVER-1352
+     * @see https://issues.apache.org/jira/browse/DIRSERVER-1157
+     * @throws Exception
+     */
+    @Test
+    public void testAddDeleteAlias2() throws Exception
+    {
+        // use a partition with suffix size 2
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE_EXAMPLE_COM );
+
+        // Create entry ou=favorite,dc=example,dc=com
+        Attributes entry = new BasicAttributes( true );
+        javax.naming.directory.Attribute entryOcls = new BasicAttribute( SchemaConstants.OBJECT_CLASS_AT );
+        entryOcls.add( SchemaConstants.TOP_OC );
+        entryOcls.add( SchemaConstants.ORGANIZATIONAL_UNIT_OC );
+        entry.put( entryOcls );
+        entry.put( SchemaConstants.OU_AT, "favorite" );
+        String entryRdn = "ou=favorite";
+        ctx.createSubcontext( entryRdn, entry );
+
+        // Create Alias ou=bestFruit,dc=example,dc=com to ou=favorite
+        String aliasedObjectName = entryRdn + "," + ctx.getNameInNamespace();
+        Attributes alias = new BasicAttributes( true );
+        javax.naming.directory.Attribute aliasOcls = new BasicAttribute( SchemaConstants.OBJECT_CLASS_AT );
+        aliasOcls.add( SchemaConstants.TOP_OC );
+        aliasOcls.add( SchemaConstants.EXTENSIBLE_OBJECT_OC );
+        aliasOcls.add( SchemaConstants.ALIAS_OC );
+        alias.put( aliasOcls );
+        alias.put( SchemaConstants.OU_AT, "bestFruit" );
+        alias.put( SchemaConstants.ALIASED_OBJECT_NAME_AT, aliasedObjectName );
+        String rdnAlias = "ou=bestFruit";
+        ctx.createSubcontext( rdnAlias, alias );
+
+        // Remove alias and entry
+        ctx.destroySubcontext( rdnAlias ); //Waiting for Connection.reply()
+        ctx.destroySubcontext( entryRdn );
+    }
+
+
+    /**
+     * Test for DIRSERVER-1352:  Infinite Loop when deleting an alias with suffix size > 1
+     * Test for DIRSERVER-1157:  Deleting Alias entry failure
+     * 
+     * @see https://issues.apache.org/jira/browse/DIRSERVER-1352
+     * @see https://issues.apache.org/jira/browse/DIRSERVER-1157
+     * @throws Exception
+     */
+    @Test
+    public void testAddDeleteAlias3() throws Exception
+    {
+        // use a partition with suffix size 3
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE_DIRECTORY_APACHE_ORG );
+
+        // Create entry ou=favorite,dc=directory,dc=apache,dc=org
+        Attributes entry = new BasicAttributes( true );
+        javax.naming.directory.Attribute entryOcls = new BasicAttribute( SchemaConstants.OBJECT_CLASS_AT );
+        entryOcls.add( SchemaConstants.TOP_OC );
+        entryOcls.add( SchemaConstants.ORGANIZATIONAL_UNIT_OC );
+        entry.put( entryOcls );
+        entry.put( SchemaConstants.OU_AT, "favorite" );
+        String entryRdn = "ou=favorite";
+        ctx.createSubcontext( entryRdn, entry );
+
+        // Create Alias ou=bestFruit,dc=directory,dc=apache,dc=org to ou=favorite
+        String aliasedObjectName = entryRdn + "," + ctx.getNameInNamespace();
+        Attributes alias = new BasicAttributes( true );
+        javax.naming.directory.Attribute aliasOcls = new BasicAttribute( SchemaConstants.OBJECT_CLASS_AT );
+        aliasOcls.add( SchemaConstants.TOP_OC );
+        aliasOcls.add( SchemaConstants.EXTENSIBLE_OBJECT_OC );
+        aliasOcls.add( SchemaConstants.ALIAS_OC );
+        alias.put( aliasOcls );
+        alias.put( SchemaConstants.OU_AT, "bestFruit" );
+        alias.put( SchemaConstants.ALIASED_OBJECT_NAME_AT, aliasedObjectName );
+        String rdnAlias = "ou=bestFruit";
+        ctx.createSubcontext( rdnAlias, alias );
+
+        // Remove alias and entry
+        ctx.destroySubcontext( rdnAlias ); //Waiting for Connection.reply()
+        ctx.destroySubcontext( entryRdn );
+    }
+
+
+    /**
+     * Tests add operation on referral entry with the ManageDsaIT control.
+     */
+    @Test
+    public void testOnReferralWithManageDsaITControl() throws Exception
+    {
+        LDAPConnection conn = getNsdkWiredConnection( getLdapServer() );
+        LDAPConstraints constraints = new LDAPSearchConstraints();
+        constraints.setClientControls( new LDAPControl( LDAPControl.MANAGEDSAIT, true, new byte[0] ) );
+        constraints.setServerControls( new LDAPControl( LDAPControl.MANAGEDSAIT, true, new byte[0] ) );
+        conn.setConstraints( constraints );
+
+        // add success
+        LDAPAttributeSet attrSet = new LDAPAttributeSet();
+        attrSet.add( new LDAPAttribute( "objectClass", "organizationalUnit" ) );
+        attrSet.add( new LDAPAttribute( "ou", "UnderReferral" ) );
+        LDAPEntry entry = new LDAPEntry( "ou=UnderReferral,uid=akarasuluref,ou=users,ou=system", attrSet );
+
+        try
+        {
+            conn.add( entry, constraints );
+            fail();
+        }
+        catch ( LDAPException le )
+        {
+            assertEquals( ResultCodeEnum.REFERRAL.getValue(), le.getLDAPResultCode() );
+        }
+
+        try
+        {
+            conn.read( "ou=UnderReferral,uid=akarasuluref,ou=users,ou=system", ( LDAPSearchConstraints ) constraints );
+            fail();
+        }
+        catch ( LDAPException le )
+        {
+
+        }
+
+        conn.disconnect();
+    }
+
+
+    public static LdapContext getContext( String principalDn, DirectoryService service, String dn ) throws Exception
+    {
+        if ( principalDn == null )
+        {
+            principalDn = "";
+        }
+
+        Dn userDn = new Dn( service.getSchemaManager(), principalDn );
+        LdapPrincipal principal = new LdapPrincipal( service.getSchemaManager(), userDn, AuthenticationLevel.SIMPLE );
+
+        if ( dn == null )
+        {
+            dn = "";
+        }
+
+        CoreSession session = service.getSession( principal );
+        LdapContext ctx = new ServerLdapContext( service, session, new LdapName( dn ) );
+        return ctx;
+    }
+
+
+    /**
+     * Tests add operation on referral entry with the ManageDsaIT control.
+     */
+    @Test
+    public void testOnReferralWitJNDIIgnore() throws Exception
+    {
+        LdapContext MNNCtx = getContext( ServerDNConstants.ADMIN_SYSTEM_DN, getLdapServer().getDirectoryService(),
+            "uid=akarasuluref,ou=users,ou=system" );
+
+        // Set to 'ignore'
+        MNNCtx.addToEnvironment( Context.REFERRAL, "ignore" );
+
+        try
+        {
+            // JNDI entry
+            Attributes userEntry = new BasicAttributes( "objectClass", "top", true );
+            userEntry.get( "objectClass" ).add( "person" );
+            userEntry.put( "sn", "elecharny" );
+            userEntry.put( "cn", "Emmanuel Lecharny" );
+
+            MNNCtx.createSubcontext( "cn=Emmanuel Lecharny, ou=apache, ou=people", userEntry );
+            fail();
+        }
+        catch ( PartialResultException pre )
+        {
+            assertTrue( true );
+        }
+    }
+
+
+    /**
+     * Tests referral handling when an ancestor is a referral.
+     */
+    @Test
+    public void testAncestorReferral() throws Exception
+    {
+        LOG.debug( "" );
+
+        LDAPConnection conn = getNsdkWiredConnection( getLdapServer() );
+        LDAPConstraints constraints = new LDAPConstraints();
+        conn.setConstraints( constraints );
+
+        // referrals failure
+        LDAPAttributeSet attrSet = new LDAPAttributeSet();
+        attrSet.add( new LDAPAttribute( "objectClass", "organizationalUnit" ) );
+        attrSet.add( new LDAPAttribute( "ou", "UnderReferral" ) );
+        LDAPEntry entry = new LDAPEntry( "ou=UnderReferral,ou=Computers,uid=akarasuluref,ou=users,ou=system", attrSet );
+
+        LDAPResponseListener listener = conn.add( entry, null, constraints );
+        LDAPResponse response = listener.getResponse();
+        assertEquals( ResultCodeEnum.REFERRAL.getValue(), response.getResultCode() );
+
+        assertEquals( "ldap://localhost:10389/ou=UnderReferral,ou=Computers,uid=akarasulu,ou=users,ou=system", response
+            .getReferrals()[0] );
+        assertEquals( "ldap://foo:10389/ou=UnderReferral,ou=Computers,uid=akarasulu,ou=users,ou=system", response
+            .getReferrals()[1] );
+        assertEquals( "ldap://bar:10389/ou=UnderReferral,ou=Computers,uid=akarasulu,ou=users,ou=system", response
+            .getReferrals()[2] );
+
+        conn.disconnect();
+    }
+
+
+    /**
+     * Tests add operation on normal and referral entries without the 
+     * ManageDsaIT control. Referrals are sent back to the client with a
+     * non-success result code.
+     */
+    @Test
+    public void testOnReferral() throws Exception
+    {
+        LDAPConnection conn = getNsdkWiredConnection( getLdapServer() );
+        LDAPConstraints constraints = new LDAPConstraints();
+        constraints.setReferrals( false );
+        conn.setConstraints( constraints );
+
+        // referrals failure
+
+        LDAPAttributeSet attrSet = new LDAPAttributeSet();
+        attrSet.add( new LDAPAttribute( "objectClass", "organizationalUnit" ) );
+        attrSet.add( new LDAPAttribute( "ou", "UnderReferral" ) );
+        LDAPEntry entry = new LDAPEntry( "ou=UnderReferral,uid=akarasuluref,ou=users,ou=system", attrSet );
+
+        LDAPResponseListener listener = null;
+        LDAPResponse response = null;
+        listener = conn.add( entry, null, constraints );
+        response = listener.getResponse();
+
+        assertEquals( ResultCodeEnum.REFERRAL.getValue(), response.getResultCode() );
+
+        assertEquals( "ldap://localhost:10389/ou=UnderReferral,uid=akarasulu,ou=users,ou=system", response
+            .getReferrals()[0] );
+        assertEquals( "ldap://foo:10389/ou=UnderReferral,uid=akarasulu,ou=users,ou=system", response.getReferrals()[1] );
+        assertEquals( "ldap://bar:10389/ou=UnderReferral,uid=akarasulu,ou=users,ou=system", response.getReferrals()[2] );
+
+        conn.disconnect();
+    }
+
+
+    /**
+     * Tests add operation on normal and referral entries without the 
+     * ManageDsaIT control using JNDI instead of the Netscape API. Referrals 
+     * are sent back to the client with a non-success result code.
+     */
+    @Test
+    public void testThrowOnReferralWithJndi() throws Exception
+    {
+        LdapContext ctx = getWiredContextThrowOnRefferal( getLdapServer() );
+        SearchControls controls = new SearchControls();
+        controls.setReturningAttributes( new String[0] );
+        controls.setSearchScope( SearchControls.OBJECT_SCOPE );
+
+        // add failure
+        Attributes attrs = new BasicAttributes( "objectClass", "organizationalUnit", true );
+        attrs.put( "ou", "UnderReferral" );
+
+        try
+        {
+            ctx.createSubcontext( "ou=UnderReferral,uid=akarasuluref,ou=users,ou=system", attrs );
+            fail( "Should never get here: add should fail with ReferralExcpetion" );
+        }
+        catch ( ReferralException e )
+        {
+            assertEquals( "ldap://localhost:10389/ou=UnderReferral,uid=akarasulu,ou=users,ou=system", e
+                .getReferralInfo() );
+        }
+
+        ctx.close();
+    }
+
+
+    /**
+     * Test for DIRSERVER-1183.
+     * 
+     * @see https://issues.apache.org/jira/browse/DIRSERVER-1183
+     * @throws Exception
+     */
+    @Test
+    public void testDIRSERVER_1183() throws Exception
+    {
+        LdapContext ctx = ( LdapContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+        Attributes attrs = new BasicAttributes( "objectClass", "inetOrgPerson", true );
+        attrs.get( "objectClass" ).add( "organizationalPerson" );
+        attrs.get( "objectClass" ).add( "person" );
+        attrs.put( "givenName", "Jim" );
+        attrs.put( "sn", "Bean" );
+        attrs.put( "cn", "Jim, Bean" );
+
+        DirContext jimBeanCtx = ctx.createSubcontext( "cn=\"Jim, Bean\"", attrs );
+        
+        assertNotNull( jimBeanCtx );
+    }
+
+
+    /**
+     * Create an entry a Rdn which is not present in the entry
+     */
+    @Test
+    public void testAddEntryNoRDNInEntry() throws Exception
+    {
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        // Create a person
+        Attributes person = new BasicAttributes( "objectClass", "inetOrgPerson", true );
+        person.get( "objectClass" ).add( "top" );
+        person.get( "objectClass" ).add( "person" );
+        person.get( "objectClass" ).add( "organizationalPerson" );
+        person.put( "sn", "Michael Jackson" );
+        person.put( "cn", "Jackson" );
+
+        DirContext michaelCtx = ctx.createSubcontext( "givenname=Michael", person );
+
+        assertNotNull( michaelCtx );
+
+        DirContext jackson = ( DirContext ) ctx.lookup( "givenname=Michael" );
+        person = jackson.getAttributes( "" );
+        javax.naming.directory.Attribute newOcls = person.get( "objectClass" );
+
+        String[] expectedOcls =
+            { "top", "person", "organizationalPerson", "inetOrgPerson" };
+
+        for ( String name : expectedOcls )
+        {
+            assertTrue( "object class " + name + " is present", newOcls.contains( name ) );
+        }
+
+        javax.naming.directory.Attribute givenName = person.get( "givenname" );
+
+        assertEquals( "Michael", givenName.get() );
+    }
+
+
+    /**
+     * Create an entry a Rdn which is not present in the entry, but
+     * with another attribute's value
+     */
+    @Test
+    public void testAddEntryDifferentRDNInEntry() throws Exception
+    {
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        // Create a person
+        Attributes person = new BasicAttributes( "objectClass", "inetOrgPerson", true );
+        person.get( "objectClass" ).add( "top" );
+        person.get( "objectClass" ).add( "person" );
+        person.get( "objectClass" ).add( "organizationalPerson" );
+        person.put( "givenName", "Michael" );
+        person.put( "sn", "Michael Jackson" );
+        person.put( "cn", "Jackson" );
+
+        DirContext michaelCtx = ctx.createSubcontext( "cn=Michael", person );
+
+        assertNotNull( michaelCtx );
+
+        DirContext jackson = ( DirContext ) ctx.lookup( "cn=Michael" );
+        person = jackson.getAttributes( "" );
+        javax.naming.directory.Attribute newOcls = person.get( "objectClass" );
+
+        String[] expectedOcls =
+            { "top", "person", "organizationalPerson", "inetOrgPerson" };
+
+        for ( String name : expectedOcls )
+        {
+            assertTrue( "object class " + name + " is present", newOcls.contains( name ) );
+        }
+
+        javax.naming.directory.Attribute cn = person.get( "cn" );
+
+        assertEquals( 2, cn.size() );
+        String[] expectedCns =
+            { "Jackson", "michael" };
+
+        for ( String name : expectedCns )
+        {
+            assertTrue( "CN " + name + " is present", cn.contains( name ) );
+        }
+    }
+
+
+    /**
+     * Create an entry a Rdn which is not present in the entry,
+     * with another attribute's value, and on a SingleValued attribute
+     */
+    @Test
+    public void testAddEntryDifferentRDNSingleValuedInEntry() throws Exception
+    {
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        // Create a person
+        Attributes person = new BasicAttributes( "objectClass", "inetOrgPerson", true );
+        person.get( "objectClass" ).add( "top" );
+        person.get( "objectClass" ).add( "person" );
+        person.get( "objectClass" ).add( "organizationalPerson" );
+        person.put( "displayName", "Michael" );
+        person.put( "sn", "Michael Jackson" );
+        person.put( "cn", "Jackson" );
+
+        DirContext michaelCtx = ctx.createSubcontext( "displayName=test", person );
+
+        assertNotNull( michaelCtx );
+
+        DirContext jackson = ( DirContext ) ctx.lookup( "displayName=test" );
+        person = jackson.getAttributes( "" );
+        javax.naming.directory.Attribute newOcls = person.get( "objectClass" );
+
+        String[] expectedOcls =
+            { "top", "person", "organizationalPerson", "inetOrgPerson" };
+
+        for ( String name : expectedOcls )
+        {
+            assertTrue( "object class " + name + " is present", newOcls.contains( name ) );
+        }
+
+        // Check that the displayName attribute has been replaced
+        javax.naming.directory.Attribute displayName = person.get( "displayName" );
+
+        assertEquals( 1, displayName.size() );
+        assertTrue( displayName.contains( "test" ) );
+    }
+
+
+    /**
+     * Create an entry a composed Rdn which is not present in the entry,
+     * with another attribute's value, and on a SingleValued attribute
+     */
+    @Test
+    public void testAddEntryComposedRDN() throws Exception
+    {
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        // Create a person
+        Attributes person = new BasicAttributes( "objectClass", "inetOrgPerson", true );
+        person.get( "objectClass" ).add( "top" );
+        person.get( "objectClass" ).add( "person" );
+        person.get( "objectClass" ).add( "organizationalPerson" );
+        person.put( "sn", "Michael Jackson" );
+        person.put( "cn", "Jackson" );
+
+        DirContext michaelCtx = ctx.createSubcontext( "displayName=test+cn=Michael", person );
+
+        assertNotNull( michaelCtx );
+
+        DirContext jackson = ( DirContext ) ctx.lookup( "displayName=test+cn=Michael" );
+        person = jackson.getAttributes( "" );
+        javax.naming.directory.Attribute newOcls = person.get( "objectClass" );
+
+        String[] expectedOcls =
+            { "top", "person", "organizationalPerson", "inetOrgPerson" };
+
+        for ( String name : expectedOcls )
+        {
+            assertTrue( "object class " + name + " is present", newOcls.contains( name ) );
+        }
+
+        // Check that the DIsplayName attribute has been added
+        javax.naming.directory.Attribute displayName = person.get( "displayName" );
+
+        assertEquals( 1, displayName.size() );
+        assertTrue( displayName.contains( "test" ) );
+
+        // Check that the cn attribute value has been added
+        javax.naming.directory.Attribute cn = person.get( "cn" );
+
+        assertEquals( 2, cn.size() );
+        assertTrue( cn.contains( "Jackson" ) );
+        assertTrue( cn.contains( "michael" ) );
+    }
+
+
+    /**
+     * Test that if we inject a PDU above the max allowed size,
+     * the connection is closed. 
+     * 
+     * @throws NamingException 
+     */
+    @Test
+    public void testAddPDUExceedingMaxSizeJNDI() throws Exception
+    {
+        // Limit the PDU size to 1024
+        getLdapServer().getDirectoryService().setMaxPDUSize( 1024 );
+        DirContext ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        // modify object classes, add two more
+        Attributes attributes = new BasicAttributes( true );
+        javax.naming.directory.Attribute ocls = new BasicAttribute( "description" );
+
+        // Inject a 1024 bytes long description
+        StringBuilder sb = new StringBuilder();
+
+        for ( int i = 0; i < 128; i++ )
+        {
+            sb.append( "0123456789ABCDEF" );
+        }
+
+        ocls.add( sb.toString() );
+        attributes.put( ocls );
+
+        DirContext person = ( DirContext ) ctx.lookup( RDN );
+
+        try
+        {
+            person.modifyAttributes( "", DirContext.ADD_ATTRIBUTE, attributes );
+            fail();
+        }
+        catch ( Exception e )
+        {
+            // We are expecting the session to be close here.
+        }
+
+        // Test again with a bigger size
+        // Limit the PDU size to 1024
+        getLdapServer().getDirectoryService().setMaxPDUSize( 4096 );
+
+        ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+        person = ( DirContext ) ctx.lookup( RDN );
+
+        try
+        {
+            person.modifyAttributes( "", DirContext.ADD_ATTRIBUTE, attributes );
+        }
+        catch ( Exception e )
+        {
+            // We should not go there
+            fail();
+        }
+
+        // Read again from directory
+        ctx = ( DirContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+        person = ( DirContext ) ctx.lookup( RDN );
+
+        assertNotNull( person );
+        attributes = person.getAttributes( "" );
+        javax.naming.directory.Attribute newOcls = attributes.get( "objectClass" );
+
+        assertNotNull( newOcls );
+    }
+
+
+    /**
+     * Test that if we inject a PDU above the max allowed size,
+     * the connection is closed. 
+     * 
+     * @throws NamingException 
+     */
+    @Test
+    public void testAddPDUExceedingMaxSizeLdapApi() throws Exception
+    {
+        // Limit the PDU size to 1024
+        getLdapServer().getDirectoryService().setMaxPDUSize( 1024 );
+        LdapConnection connection = new LdapNetworkConnection( "localhost", getLdapServer().getPort() );
+        connection.bind( "uid=admin,ou=system", "secret" );
+
+        // Inject a 1024 bytes long description
+        StringBuilder sb = new StringBuilder();
+
+        for ( int i = 0; i < 128; i++ )
+        {
+            sb.append( "0123456789ABCDEF" );
+        }
+
+        Attribute description = new DefaultAttribute( "description", sb.toString() );
+
+        try
+        {
+            Modification modification = new DefaultModification( ModificationOperation.ADD_ATTRIBUTE, description );
+            connection.modify( "cn=the person, ou=system", modification );
+            fail();
+        }
+        catch ( Exception e )
+        {
+            // We are expecting the session to be close here.
+            if ( connection.isConnected() )
+            {
+                // Race condition:
+                // Upon NoticeOfDisconnection the API sends an abandon request but does not immediately close the connection.
+                // So at this point it is not guaranteed that the connnection is already closed.
+                // TODO: This is just a workaround, better check the connection for any outstanding abandon requests
+                Thread.sleep( 1000 );
+            }
+            assertFalse( connection.isConnected() );
+        }
+    }
+
+
+    /**
+     * Test for DIRSERVER-1311: If the Rdn attribute+value is not present
+     * in the entry the server should implicit add this attribute+value to
+     * the entry. Additionally, if the Rdn value is escaped or a hexstring
+     * the server must add the unescaped string or binary value to the entry.
+     */
+    @Test
+    public void testAddUnescapedRdnValue_DIRSERVER_1311() throws Exception
+    {
+        LdapContext ctx = ( LdapContext ) getWiredContext( getLdapServer() ).lookup( BASE );
+
+        Attributes tori = new BasicAttributes( true );
+        javax.naming.directory.Attribute toriOC = new BasicAttribute( "objectClass" );
+        toriOC.add( "top" );
+        toriOC.add( "person" );
+        tori.put( toriOC );
+        //tori.put( "cn", "Amos,Tori" );
+        tori.put( "cn", "Tori,Amos" );
+        tori.put( "sn", "Amos" );
+        /*
+         * Note that the Rdn attribute is different to the cn specified in the entry.
+         * This creates a second cn attribute "cn:Amos,Tori". This is a JNDI hack:
+         * If no other cn is available in the entry, JNDI adds the Rdn
+         * attribute to the entry before sending the request to the server.
+         */
+        ctx.createSubcontext( " cn = Amos\\,Tori ", tori );
+
+        Attributes binary = new BasicAttributes( true );
+        javax.naming.directory.Attribute binaryOC = new BasicAttribute( "objectClass" );
+        binaryOC.add( "top" );
+        binaryOC.add( "person" );
+        binary.put( binaryOC );
+        binary.put( "cn", "Binary" );
+        binary.put( "sn", "Binary" );
+        binary.put( "userPassword", "test" );
+        /*
+         * Note that the Rdn attribute is different to the userPassword specified
+         * in the entry. This creates a second cn attribute "userPassword:#414243". 
+         * This is a JNDI hack:
+         * If no other userPassword is available in the entry, JNDI adds the Rdn
+         * attribute to the entry before sending the request to the server.
+         */
+        ctx.createSubcontext( " userPassword = #414243 ", binary );
+
+        SearchControls controls = new SearchControls();
+        NamingEnumeration<SearchResult> res;
+
+        // search for the implicit added cn
+        res = ctx.search( "", "(cn=Amos,Tori)", controls );
+        assertTrue( res.hasMore() );
+        javax.naming.directory.Attribute cnAttribute = res.next().getAttributes().get( "cn" );
+        assertEquals( 2, cnAttribute.size() );
+        assertTrue( cnAttribute.contains( "Tori,Amos" ) );
+        assertTrue( cnAttribute.contains( "amos,tori" ) );
+        assertFalse( res.hasMore() );
+
+        // search for the implicit added userPassword
+        res = ctx.search( "", "(userPassword=\\41\\42\\43)", controls );
+        assertTrue( res.hasMore() );
+        javax.naming.directory.Attribute userPasswordAttribute = res.next().getAttributes().get( "userPassword" );
+        assertEquals( 2, userPasswordAttribute.size() );
+        assertTrue( userPasswordAttribute.contains( Strings.getBytesUtf8( "test" ) ) );
+        assertTrue( userPasswordAttribute.contains( Strings.getBytesUtf8( "ABC" ) ) );
+        assertFalse( res.hasMore() );
+    }
+
+
+    @Test
+    public void testAddEntryUUIDAndCSNAttributes() throws Exception
+    {
+        LdapConnection con = getAdminConnection( getLdapServer() );
+
+        String dn = "cn=Kate Bush," + BASE;
+        Entry entry = new DefaultEntry( dn );
+        entry.add( "objectclass", "top", "person" );
+        entry.add( "sn", "Bush" );
+        entry.add( "cn", "Kate Bush" );
+
+        String descr = "a British singer-songwriter with an expressive four-octave voice";
+        entry.add( "description", descr );
+
+        UUID uuid = UUID.randomUUID();
+        entry.add( SchemaConstants.ENTRY_UUID_AT, uuid.toString() );
+
+        CsnFactory csnFac = new CsnFactory( 0 );
+        Csn csn = csnFac.newInstance();
+        entry.add( SchemaConstants.ENTRY_CSN_AT, csn.toString() );
+
+        con.add( entry );
+
+        // Analyze entry and description attribute
+        Entry addedEntry = con.lookup( dn, "*", "+" );
+        assertNotNull( addedEntry );
+
+        Attribute attr = addedEntry.get( SchemaConstants.ENTRY_UUID_AT );
+        assertNotNull( attr );
+
+        assertEquals( uuid.toString(), attr.getString() );
+
+        attr = addedEntry.get( SchemaConstants.ENTRY_CSN_AT );
+        assertNotNull( attr );
+        assertEquals( csn.toString(), attr.getString() );
+
+        // Remove entry
+        con.delete( dn );
+        con.unBind();
+    }
+
+
+    protected Attributes getPersonAttributes( String sn, String cn )
+    {
+        Attributes attrs = new BasicAttributes( true );
+        javax.naming.directory.Attribute ocls = new BasicAttribute( "objectClass" );
+        ocls.add( "top" );
+        ocls.add( "person" );
+        attrs.put( ocls );
+        attrs.put( "cn", cn );
+        attrs.put( "sn", sn );
+
+        return attrs;
+    }
+
+
+    protected Attributes getOrgUnitAttributes( String ou )
+    {
+        Attributes attrs = new BasicAttributes( true );
+        javax.naming.directory.Attribute ocls = new BasicAttribute( "objectClass" );
+        ocls.add( "top" );
+        ocls.add( "organizationalUnit" );
+        attrs.put( ocls );
+        attrs.put( "ou", ou );
+
+        return attrs;
+    }
+
+
+    /**
+     * <pre>
+     * ou=system
+     *   |--ou=sales
+     *   |    |--cn=real  <--real entry
+     *   |--ou=engineering
+     *        |--cn=alias  <--alias, pointing to the real entry
+     * </pre>
+     * 
+     * @throws NamingException 
+     */
+    @Test
+    @CreateDS( 
+        enableChangeLog = false,
+        name = "DSAlias" )
+    @CreateLdapServer( name = "DSAlias", transports =
+        { @CreateTransport(protocol = "LDAP", port = -1) })
+    public void test_DIRSERVER_1357() throws Exception
+    {
+        DirContext ctx = ( DirContext ) ServerIntegrationUtils.getWiredContext( getLdapServer() ).lookup( "ou=system" );
+
+        Attributes salesAttrs = getOrgUnitAttributes( "sales" );
+        ctx.createSubcontext( "ou=sales", salesAttrs );
+
+        Attributes engAttrs = getOrgUnitAttributes( "engineering" );
+        ctx.createSubcontext( "ou=engineering", engAttrs );
+
+        // The real entry under ou=sales
+        Attributes fooAttrs = getPersonAttributes( "real", "real" );
+        ctx.createSubcontext( "cn=real,ou=sales", fooAttrs );
+
+        // The alias under ou=engineering, pointing to the real entry
+        Attributes aliasAttrs = new BasicAttributes( true );
+        javax.naming.directory.Attribute aliasOC = new BasicAttribute( "objectClass" );
+        aliasOC.add( "top" );
+        aliasOC.add( "alias" );
+        aliasOC.add( "extensibleObject" );
+        aliasAttrs.put( aliasOC );
+        aliasAttrs.put( "cn", "alias" );
+        aliasAttrs.put( "aliasedObjectName", "cn=real,ou=sales,ou=system" );
+        ctx.createSubcontext( "cn=alias,ou=engineering", aliasAttrs );
+
+        // Delete the real entry first
+        ctx.destroySubcontext( "cn=real,ou=sales" );
+
+        // Now the alias entry still exists, but points to nowhere.
+        // When trying to delete the alias entry an exception occurs.
+        ctx.destroySubcontext( "cn=alias,ou=engineering" );
+    }
+
+    /**
+     * Adding an entry with a non existing attribute type.
+     * 
+     * @throws Exception 
+     */
+    @Test
+    public void testAddEntryNonExistingAT() throws Exception
+    {
+        LdapConnection connection = getAdminConnection( getLdapServer() );
+
+        Dn dn = new Dn( "cn=Kate Bush," + BASE );
+
+        Entry personEntry = new DefaultEntry();
+        personEntry.add( SchemaConstants.OBJECT_CLASS_AT, "person" );
+        personEntry.add( SchemaConstants.CN_AT, "Kate Bush" );
+        personEntry.add( SchemaConstants.SN_AT, "Bush" );
+        personEntry.add( "nonExistingAttribute", "value" );
+        personEntry.setDn( dn );
+
+        try
+        {
+            connection.add( personEntry );
+            fail("should throw LdapNoSuchAttributeException");
+        }
+        catch( LdapNoSuchAttributeException e )
+        {
+            //expected exception
+        }
+
+        Entry entry = connection.lookup( dn );
+        assertNull( entry );
+
+        connection.close();
+    }
+
+
+    /**
+     * Adding an entry with a non existing attribute type.
+     * 
+     * @throws Exception 
+     */
+    @Test( expected = LdapOperationException.class )
+    public void testAddEntryNonExistingOC() throws Exception
+    {
+        LdapConnection connection = getAdminConnection( getLdapServer() );
+
+        Dn dn = new Dn( "cn=Kate Bush," + BASE );
+
+        Entry personEntry = new DefaultEntry();
+        personEntry.add( SchemaConstants.OBJECT_CLASS_AT, "nonexistingOC" );
+        personEntry.add( SchemaConstants.CN_AT, "Kate Bush" );
+        personEntry.add( SchemaConstants.SN_AT, "Bush" );
+        personEntry.setDn( dn );
+
+        connection.add( personEntry );
+    }
+
+
+    /**
+     * Adding an entry with a 100K attribute's value.
+     * 
+     * @throws Exception 
+     */
+    @Test( expected = LdapException.class )
+    public void testAddEntry100KData() throws Exception
+    {
+        LdapConnection connection = getAdminConnection( getLdapServer() );
+
+        int size = 100*1024;
+        byte[] dataBytes = new byte[size];
+        
+        for ( int i = 0; i < size; i++)
+        {
+            dataBytes[i] = 'A';
+        }
+        
+        String data = Strings.utf8ToString( dataBytes );
+
+        Dn dn = new Dn( "cn=Kate Bush," + BASE );
+        
+        Entry personEntry = new DefaultEntry( "cn=Kate Bush," + BASE,
+        "objectClass: top",
+        "objectClass: person",
+        "cn: Kate Bush",
+        "sn: Bush",
+        "description", data );
+
+        connection.add( personEntry );
+        
+        // Check that the entry has been stored 
+        Entry entry = connection.lookup( dn, "description", "cn", "sn" );
+        
+        String description = entry.get( "description" ).getString();
+        
+        assertNotNull( description );
+        assertTrue( description.startsWith( "AAA" ) );
+        assertEquals( size, description.length() );
+        
+        for ( int i = 0; i < size; i++ )
+        {
+            assertEquals( 'A', description.charAt( i ) );
+        }
+    }
+}

Added: directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/BindIT.java
URL: http://svn.apache.org/viewvc/directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/BindIT.java?rev=1178423&view=auto
==============================================================================
--- directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/BindIT.java (added)
+++ directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/BindIT.java Mon Oct  3 14:59:19 2011
@@ -0,0 +1,205 @@
+/*
+ *   Licensed to the Apache Software Foundation (ASF) under one
+ *   or more contributor license agreements.  See the NOTICE file
+ *   distributed with this work for additional information
+ *   regarding copyright ownership.  The ASF licenses this file
+ *   to you under the Apache License, Version 2.0 (the
+ *   "License"); you may not use this file except in compliance
+ *   with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing,
+ *   software distributed under the License is distributed on an
+ *   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *   KIND, either express or implied.  See the License for the
+ *   specific language governing permissions and limitations
+ *   under the License.
+ *
+ */
+package org.apache.directory.server.operations.ldapsdk;
+
+
+import static org.apache.directory.server.integ.ServerIntegrationUtils.getWiredContext;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import javax.naming.AuthenticationException;
+import javax.naming.InvalidNameException;
+
+import netscape.ldap.LDAPConnection;
+import netscape.ldap.LDAPConstraints;
+import netscape.ldap.LDAPControl;
+import netscape.ldap.LDAPException;
+
+import org.apache.directory.junit.tools.MultiThreadedMultiInvoker;
+import org.apache.directory.server.annotations.CreateLdapServer;
+import org.apache.directory.server.annotations.CreateTransport;
+import org.apache.directory.server.core.annotations.ApplyLdifs;
+import org.apache.directory.server.core.annotations.CreateDS;
+import org.apache.directory.server.core.integ.AbstractLdapTestUnit;
+import org.apache.directory.server.core.integ.FrameworkRunner;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+
+/**
+ * Tests the server to make sure standard compare operations work properly.
+ *
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ */
+@RunWith(FrameworkRunner.class)
+@ApplyLdifs(
+    {
+        // Entry # 1
+        "dn: uid=akarasulu,ou=users,ou=system",
+        "objectClass: uidObject",
+        "objectClass: person",
+        "objectClass: top",
+        "uid: akarasulu",
+        "cn: Alex Karasulu",
+        "sn: karasulu",
+        // Entry # 2
+        "dn: ou=Computers,uid=akarasulu,ou=users,ou=system",
+        "objectClass: organizationalUnit",
+        "objectClass: top",
+        "ou: computers",
+        "description: Computers for Alex",
+        "seeAlso: ou=Machines,uid=akarasulu,ou=users,ou=system",
+        // Entry # 3
+        "dn: uid=akarasuluref,ou=users,ou=system",
+        "objectClass: extensibleObject",
+        "objectClass: uidObject",
+        "objectClass: referral",
+        "objectClass: top",
+        "uid: akarasuluref",
+        "userPassword: secret",
+        "ref: ldap://localhost:10389/uid=akarasulu,ou=users,ou=system",
+        "ref: ldap://foo:10389/uid=akarasulu,ou=users,ou=system",
+        "ref: ldap://bar:10389/uid=akarasulu,ou=users,ou=system" })
+@CreateDS(allowAnonAccess = true, name = "BindIT-class")
+@CreateLdapServer(
+    transports =
+    {
+        @CreateTransport(protocol = "LDAP")
+    })
+public class BindIT extends AbstractLdapTestUnit
+{
+    @Rule
+    public MultiThreadedMultiInvoker i = new MultiThreadedMultiInvoker( MultiThreadedMultiInvoker.NOT_THREADSAFE );
+
+
+    /**
+     * Test with bindDn which is not even found under any namingContext of the
+     * server.
+     * 
+     * @throws Exception 
+     */
+    @Test
+    public void testBadBindDnNotInContext() throws Exception
+    {
+        try
+        {
+            getWiredContext( getLdapServer(), "cn=bogus", "blah" );
+            fail( "should never get here due to a " );
+        }
+        catch ( AuthenticationException e )
+        {
+        }
+    }
+
+
+    /**
+     * Test bind with malformed bind Dn.
+     */
+    @Test
+    public void testBadBindDnMalformed() throws Exception
+    {
+        try
+        {
+            getWiredContext( getLdapServer(), "system", "blah" );
+            fail( "should never get here due to a " );
+        }
+        catch ( InvalidNameException e ){}
+    }
+
+    /**
+     * Test with bindDn that is under a naming context but points to non-existant user.
+     * 
+     * @throws Exception 
+     */
+    @Test
+    public void testBadBindDnInContext() throws Exception
+    {
+        try
+        {
+            getWiredContext( getLdapServer(), "cn=bogus,ou=system", "blah" );
+            fail( "should never get here due to a " );
+        }
+        catch ( AuthenticationException e )
+        {
+        }
+    }
+
+
+    @Test
+    public void testConnectWithIllegalLDAPVersion() throws Exception
+    {
+        LDAPConnection conn = null;
+
+        try
+        {
+            conn = new LDAPConnection();
+            conn.connect( 100, "localhost", getLdapServer().getPort(), "uid=admin,ou=system", "secret" );
+            fail( "try to connect with illegal version number should fail" );
+        }
+        catch ( LDAPException e )
+        {
+            assertEquals( "statuscode", LDAPException.PROTOCOL_ERROR, e.getLDAPResultCode() );
+        }
+        finally
+        {
+            if ( conn != null )
+            {
+                conn.disconnect();
+            }
+        }
+    }
+
+
+    /**
+     * Tests bind operation on referral entry.
+     */
+    @Test
+    public void testOnReferralWithOrWithoutManageDsaItControl() throws Exception
+    {
+        LDAPConnection conn = new LDAPConnection();
+        LDAPConstraints constraints = new LDAPConstraints();
+        constraints.setClientControls( new LDAPControl( LDAPControl.MANAGEDSAIT, true, new byte[0] ) );
+        constraints.setServerControls( new LDAPControl( LDAPControl.MANAGEDSAIT, true, new byte[0] ) );
+        conn.setConstraints( constraints );
+
+        try
+        {
+            conn.connect( 3, "localhost", getLdapServer().getPort(),
+                "uid=akarasuluref,ou=users,ou=system", "secret", constraints );
+            fail( "try to connect with illegal version number should fail" );
+        }
+        catch ( LDAPException e )
+        {
+            assertEquals( "statuscode", LDAPException.INVALID_CREDENTIALS, e.getLDAPResultCode() );
+        }
+
+        try
+        {
+            conn.connect( 3, "localhost", getLdapServer().getPort(),
+                "uid=akarasuluref,ou=users,ou=system", "secret" );
+            fail( "try to connect with illegal version number should fail" );
+        }
+        catch ( LDAPException e )
+        {
+            assertEquals( "statuscode", LDAPException.INVALID_CREDENTIALS, e.getLDAPResultCode() );
+        }
+    }
+}

Added: directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/CompareIT.java
URL: http://svn.apache.org/viewvc/directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/CompareIT.java?rev=1178423&view=auto
==============================================================================
--- directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/CompareIT.java (added)
+++ directory/apacheds/trunk/server-integ/src/test/java/org/apache/directory/server/operations/ldapsdk/CompareIT.java Mon Oct  3 14:59:19 2011
@@ -0,0 +1,293 @@
+
+/*
+ *   Licensed to the Apache Software Foundation (ASF) under one
+ *   or more contributor license agreements.  See the NOTICE file
+ *   distributed with this work for additional information
+ *   regarding copyright ownership.  The ASF licenses this file
+ *   to you under the Apache License, Version 2.0 (the
+ *   "License"); you may not use this file except in compliance
+ *   with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing,
+ *   software distributed under the License is distributed on an
+ *   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *   KIND, either express or implied.  See the License for the
+ *   specific language governing permissions and limitations
+ *   under the License.
+ *
+ */
+package org.apache.directory.server.operations.ldapsdk;
+
+
+import static org.apache.directory.server.integ.ServerIntegrationUtils.getAdminConnection;
+import static org.apache.directory.server.integ.ServerIntegrationUtils.getNsdkWiredConnection;
+import static org.apache.directory.server.integ.ServerIntegrationUtils.getWiredContextThrowOnRefferal;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import javax.naming.NamingEnumeration;
+import javax.naming.ReferralException;
+import javax.naming.directory.SearchControls;
+import javax.naming.directory.SearchResult;
+import javax.naming.ldap.LdapContext;
+
+import netscape.ldap.LDAPAttribute;
+import netscape.ldap.LDAPConnection;
+import netscape.ldap.LDAPConstraints;
+import netscape.ldap.LDAPControl;
+import netscape.ldap.LDAPException;
+import netscape.ldap.LDAPResponse;
+import netscape.ldap.LDAPResponseListener;
+
+import org.apache.directory.ldap.client.api.LdapConnection;
+import org.apache.directory.server.annotations.CreateLdapServer;
+import org.apache.directory.server.annotations.CreateTransport;
+import org.apache.directory.server.core.annotations.ApplyLdifs;
+import org.apache.directory.server.core.integ.AbstractLdapTestUnit;
+import org.apache.directory.server.core.integ.FrameworkRunner;
+import org.apache.directory.shared.ldap.model.message.ResultCodeEnum;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+/**
+ * Tests the server to make sure standard compare operations work properly.
+ *
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ */
+@RunWith(FrameworkRunner.class)
+@CreateLdapServer(transports =
+    { @CreateTransport(protocol = "LDAP") })
+@ApplyLdifs(
+    {
+        // Entry # 1
+        "dn: uid=akarasulu,ou=users,ou=system", "objectClass: uidObject", "objectClass: person",
+        "objectClass: top",
+        "uid: akarasulu",
+        "cn: Alex Karasulu",
+        "sn: karasulu",
+        // Entry # 2
+        "dn: ou=Computers,uid=akarasulu,ou=users,ou=system", "objectClass: organizationalUnit", "objectClass: top",
+        "ou: computers",
+        "description: Computers for Alex",
+        "seeAlso: ou=Machines,uid=akarasulu,ou=users,ou=system",
+        // Entry # 3
+        "dn: uid=akarasuluref,ou=users,ou=system", "objectClass: uidObject", "objectClass: referral",
+        "objectClass: top", "uid: akarasuluref", "ref: ldap://localhost:10389/uid=akarasulu,ou=users,ou=system",
+        "ref: ldap://foo:10389/uid=akarasulu,ou=users,ou=system",
+        "ref: ldap://bar:10389/uid=akarasulu,ou=users,ou=system" })
+public class CompareIT extends AbstractLdapTestUnit
+{
+    private static final Logger LOG = LoggerFactory.getLogger( CompareIT.class );
+
+
+    /**
+     * Tests normal compare operation on normal non-referral entries without 
+     * the ManageDsaIT control.
+     */
+    @Test
+    public void testNormalCompare() throws Exception
+    {
+        LdapConnection conn = getAdminConnection( getLdapServer() );
+
+        // comparison success
+        boolean response = conn.compare( "uid=akarasulu,ou=users,ou=system", "sn", "karasulu" );
+        assertTrue( response );
+
+        // comparison failure
+        response = conn.compare( "uid=akarasulu,ou=users,ou=system", "sn", "lecharny" );
+        assertFalse( response );
+
+        conn.unBind();
+        conn.close();
+    }
+
+
+    /**
+     * Tests normal compare operation on normal non-referral entries without 
+     * the ManageDsaIT control using an attribute that does not exist in the
+     * entry.
+     */
+    @Test
+    public void testNormalCompareMissingAttribute() throws Exception
+    {
+        LDAPConnection conn = getNsdkWiredConnection( getLdapServer() );
+
+        // comparison success
+        LDAPAttribute attribute = new LDAPAttribute( "sn", "karasulu" );
+        assertTrue( conn.compare( "uid=akarasulu,ou=users,ou=system", attribute ) );
+
+        // non-existing attribute
+        attribute = new LDAPAttribute( "mail", "akarasulu@apache.org" );
+
+        try
+        {
+            conn.compare( "uid=akarasulu,ou=users,ou=system", attribute );
+            fail( "Should never get here" );
+        }
+        catch ( LDAPException e )
+        {
+            assertEquals( ResultCodeEnum.NO_SUCH_ATTRIBUTE.getValue(), e.getLDAPResultCode() );
+        }
+
+        conn.disconnect();
+    }
+
+
+    /**
+     * Tests compare operation on referral entry with the ManageDsaIT control.
+     */
+    @Test
+    public void testOnReferralWithManageDsaITControl() throws Exception
+    {
+        LDAPConnection conn = getNsdkWiredConnection( getLdapServer() );
+        LDAPConstraints constraints = new LDAPConstraints();
+        constraints.setClientControls( new LDAPControl( LDAPControl.MANAGEDSAIT, true, new byte[0] ) );
+        constraints.setServerControls( new LDAPControl( LDAPControl.MANAGEDSAIT, true, new byte[0] ) );
+        conn.setConstraints( constraints );
+
+        // comparison success
+        LDAPAttribute attribute = new LDAPAttribute( "uid", "akarasuluref" );
+        assertTrue( conn.compare( "uid=akarasuluref,ou=users,ou=system", attribute, constraints ) );
+
+        // comparison failure
+        attribute = new LDAPAttribute( "uid", "elecharny" );
+        assertFalse( conn.compare( "uid=akarasuluref,ou=users,ou=system", attribute, constraints ) );
+
+        conn.disconnect();
+    }
+
+
+    /**
+     * Tests compare operation on normal and referral entries without the 
+     * ManageDsaIT control. Referrals are sent back to the client with a
+     * non-success result code.
+     */
+    @Test
+    public void testOnReferral() throws Exception
+    {
+        LDAPConnection conn = getNsdkWiredConnection( getLdapServer() );
+        LDAPConstraints constraints = new LDAPConstraints();
+        constraints.setReferrals( false );
+        conn.setConstraints( constraints );
+
+        // comparison success
+        LDAPAttribute attribute = new LDAPAttribute( "uid", "akarasulu" );
+        assertTrue( conn.compare( "uid=akarasulu,ou=users,ou=system", attribute, constraints ) );
+
+        // referrals failure
+        attribute = new LDAPAttribute( "uid", "akarasulu" );
+        LDAPResponseListener listener = null;
+        LDAPResponse response = null;
+
+        listener = conn.compare( "uid=akarasuluref,ou=users,ou=system", attribute, null, constraints );
+        response = listener.getResponse();
+        assertEquals( ResultCodeEnum.REFERRAL.getValue(), response.getResultCode() );
+
+        assertEquals( "ldap://localhost:10389/uid=akarasulu,ou=users,ou=system", response.getReferrals()[0] );
+        assertEquals( "ldap://foo:10389/uid=akarasulu,ou=users,ou=system", response.getReferrals()[1] );
+        assertEquals( "ldap://bar:10389/uid=akarasulu,ou=users,ou=system", response.getReferrals()[2] );
+
+        conn.disconnect();
+    }
+
+
+    /**
+     * Tests compare operation on normal and referral entries without the 
+     * ManageDsaIT control using JNDI instead of the Netscape API. Referrals 
+     * are sent back to the client with a non-success result code.
+     */
+    @Test
+    public void testThrowOnReferralWithJndi() throws Exception
+    {
+        LdapContext ctx = getWiredContextThrowOnRefferal( getLdapServer() );
+        SearchControls controls = new SearchControls();
+        controls.setReturningAttributes( new String[0] );
+        controls.setSearchScope( SearchControls.OBJECT_SCOPE );
+
+        // comparison success
+        NamingEnumeration<SearchResult> answer = ctx.search( "uid=akarasulu,ou=users,ou=system", "(uid=akarasulu)",
+            controls );
+        assertTrue( answer.hasMore() );
+        SearchResult result = answer.next();
+        assertEquals( "", result.getName() );
+        assertEquals( 0, result.getAttributes().size() );
+        assertFalse( answer.hasMore() );
+        answer.close();
+
+        // referrals failure
+        try
+        {
+            answer = ctx.search( "uid=akarasuluref,ou=users,ou=system", "(uid=akarasuluref)", controls );
+            fail( "Should never get here" );
+        }
+        catch ( ReferralException e )
+        {
+            // seems JNDI only returns the first referral URL and not all so we test for it
+            assertEquals( "ldap://localhost:10389/uid=akarasulu,ou=users,ou=system", e.getReferralInfo() );
+        }
+
+        ctx.close();
+    }
+
+
+    /**
+     * Check that operation are not executed if we are now allowed to bind
+     * anonymous
+     * @throws LDAPException
+     */
+    @Test
+    public void testCompareWithoutAuthentication() throws LDAPException
+    {
+        getLdapServer().getDirectoryService().setAllowAnonymousAccess( false );
+        LDAPConnection conn = new LDAPConnection();
+        conn.connect( "localhost", getLdapServer().getPort() );
+        LDAPAttribute attr = new LDAPAttribute( "uid", "admin" );
+
+        try
+        {
+            conn.compare( "uid=admin,ou=system", attr );
+            fail( "Compare success without authentication" );
+        }
+        catch ( LDAPException e )
+        {
+            assertEquals( "no permission exception", 50, e.getLDAPResultCode() );
+        }
+    }
+
+
+    /**
+     * Tests referral handling when an ancestor is a referral.
+     */
+    @Test
+    public void testAncestorReferral() throws Exception
+    {
+        LOG.debug( "" );
+
+        LDAPConnection conn = getNsdkWiredConnection( getLdapServer() );
+        LDAPConstraints constraints = new LDAPConstraints();
+        conn.setConstraints( constraints );
+
+        // referrals failure
+        LDAPAttribute attribute = new LDAPAttribute( "ou", "Computers" );
+        LDAPResponseListener listener = null;
+        LDAPResponse response = null;
+
+        listener = conn.compare( "ou=Computers,uid=akarasuluref,ou=users,ou=system", attribute, null, constraints );
+        response = listener.getResponse();
+        assertEquals( ResultCodeEnum.REFERRAL.getValue(), response.getResultCode() );
+
+        assertEquals( "ldap://localhost:10389/ou=Computers,uid=akarasulu,ou=users,ou=system",
+            response.getReferrals()[0] );
+        assertEquals( "ldap://foo:10389/ou=Computers,uid=akarasulu,ou=users,ou=system", response.getReferrals()[1] );
+        assertEquals( "ldap://bar:10389/ou=Computers,uid=akarasulu,ou=users,ou=system", response.getReferrals()[2] );
+
+        conn.disconnect();
+    }
+}



Mime
View raw message