directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From elecha...@apache.org
Subject svn commit: r366127 [3/3] - in /directory/branches/DN-refactoring/ldap-common/src: main/antlr/ main/java/org/apache/ldap/common/aci/ main/java/org/apache/ldap/common/codec/ main/java/org/apache/ldap/common/codec/add/ main/java/org/apache/ldap/common/co...
Date Thu, 05 Jan 2006 09:03:52 GMT
Added: directory/branches/DN-refactoring/ldap-common/src/test/java/org/apache/ldap/common/name/LdapDNTest.java
URL: http://svn.apache.org/viewcvs/directory/branches/DN-refactoring/ldap-common/src/test/java/org/apache/ldap/common/name/LdapDNTest.java?rev=366127&view=auto
==============================================================================
--- directory/branches/DN-refactoring/ldap-common/src/test/java/org/apache/ldap/common/name/LdapDNTest.java (added)
+++ directory/branches/DN-refactoring/ldap-common/src/test/java/org/apache/ldap/common/name/LdapDNTest.java Thu Jan  5 01:02:51 2006
@@ -0,0 +1,2145 @@
+/*
+ *   Copyright 2005 The Apache Software Foundation
+ *
+ *   Licensed 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.ldap.common.name;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.naming.InvalidNameException;
+import javax.naming.Name;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.apache.asn1.codec.DecoderException;
+import org.apache.ldap.common.name.DnParser;
+import org.apache.ldap.common.name.LdapDN;
+import org.apache.ldap.common.schema.DeepTrimToLowerNormalizer;
+import org.apache.ldap.common.schema.OidNormalizer;
+
+/**
+ * Test the class LdapDN
+ * 
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ */
+public class LdapDNTest extends TestCase
+{
+    //~ Methods ------------------------------------------------------------------------------------
+
+    /**
+     * Setup the test
+     */
+    protected void setUp()
+    {
+    }
+
+    // CONSTRUCTOR functions --------------------------------------------------
+    
+    /**
+     * Test a null DN
+     */
+    public void testLdapDNNull() throws DecoderException
+    {
+        Assert.assertEquals( "", new LdapDN().getName() );
+    }
+
+    /**
+     * test an empty DN
+     */
+    public void testLdapDNEmpty() throws InvalidNameException
+    {
+        Assert.assertEquals( "", new LdapDN( "" ).getName() );
+    }
+
+    /**
+     * test a simple DN : a = b
+     */
+    public void testLdapDNSimple() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b" );
+        Assert.assertEquals( "a = b", dn.getName() );
+        Assert.assertEquals( "a=b", dn.toString() );
+    }
+
+    /**
+     * test a composite DN : a = b, d = e
+     */
+    public void testLdapDNComposite() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b, c = d" );
+        Assert.assertEquals( "a=b,c=d", dn.toString() );
+        Assert.assertEquals( "a = b, c = d", dn.getName() );
+    }
+
+    /**
+     * test a composite DN with or without spaces: a=b, a =b, a= b, a = b, a  =  b
+     */
+    public void testLdapDNCompositeWithSpace() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, a =b, a= b, a = b, a  =  b" );
+        Assert.assertEquals( "a=b,a=b,a=b,a=b,a=b", dn.toString() );
+        Assert.assertEquals( "a=b, a =b, a= b, a = b, a  =  b", dn.getName() );
+    }
+
+    /**
+     * test a composite DN with differents separators : a=b;c=d,e=f
+     * It should return a=b,c=d,e=f (the ';' is replaced by a ',')
+     */
+    public void testLdapDNCompositeSepators() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b;c=d,e=f" );
+        Assert.assertEquals( "a=b,c=d,e=f", dn.toString() );
+        Assert.assertEquals( "a=b;c=d,e=f", dn.getName() );
+    }
+
+    /**
+     * test a simple DN with multiple NameComponents : a = b + c = d
+     */
+    public void testLdapDNSimpleMultivaluedAttribute() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b + c = d" );
+        Assert.assertEquals( "a=b+c=d", dn.toString() );
+        Assert.assertEquals( "a = b + c = d", dn.getName() );
+    }
+
+    /**
+     * test a composite DN with multiple NC and separators : a=b+c=d, e=f + g=h + i=j
+     */
+    public void testLdapDNCompositeMultivaluedAttribute() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b+c=d, e=f + g=h + i=j" );
+        Assert.assertEquals( "a=b+c=d,e=f+g=h+i=j", dn.toString() );
+        Assert.assertEquals( "a=b+c=d, e=f + g=h + i=j", dn.getName() );
+    }
+
+    /**
+     * test a simple DN with an oid prefix (uppercase) : OID.12.34.56 = azerty
+     */
+    public void testLdapDNOidUpper() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "OID.12.34.56 = azerty" );
+        Assert.assertEquals( "oid.12.34.56=azerty", dn.toString() );
+        Assert.assertEquals( "OID.12.34.56 = azerty", dn.getName() );
+    }
+
+    /**
+     * test a simple DN with an oid prefix (lowercase) : oid.12.34.56 = azerty
+     */
+    public void testLdapDNOidLower() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "oid.12.34.56 = azerty" );
+        Assert.assertEquals( "oid.12.34.56=azerty", dn.toString() );
+        Assert.assertEquals( "oid.12.34.56 = azerty", dn.getName() );
+    }
+
+    /**
+     * test a simple DN with an oid attribut without oid prefix : 12.34.56 = azerty
+     */
+    public void testLdapDNOidWithoutPrefix() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "12.34.56 = azerty" );
+        Assert.assertEquals( "12.34.56=azerty", dn.toString() );
+        Assert.assertEquals( "12.34.56 = azerty", dn.getName() );
+    }
+
+    /**
+     * test a composite DN with an oid attribut wiithout oid prefix : 12.34.56 = azerty; 7.8 = test
+     */
+    public void testLdapDNCompositeOidWithoutPrefix() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "12.34.56 = azerty; 7.8 = test" );
+        Assert.assertEquals( "12.34.56=azerty,7.8=test", dn.toString() );
+        Assert.assertEquals( "12.34.56 = azerty; 7.8 = test", dn.getName() );
+    }
+
+    /**
+     * test a simple DN with pair char attribute value : a = \,\=\+\<\>\#\;\\\"\A0\00"
+     */
+    public void testLdapDNPairCharAttributeValue() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = \\,\\=\\+\\<\\>\\#\\;\\\\\\\"\\A0\\00" );
+        Assert.assertEquals( "a=\\,\\=\\+\\<\\>\\#\\;\\\\\\\"\\A0\\00", dn.toString() );
+        Assert.assertEquals( "a = \\,\\=\\+\\<\\>\\#\\;\\\\\\\"\\A0\\00", dn.getName() );
+    }
+
+    /**
+     * test a simple DN with hexString attribute value : a = #0010A0AAFF
+     */
+    public void testLdapDNHexStringAttributeValue() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = #0010A0AAFF" );
+        Assert.assertEquals( "a=#0010A0AAFF", dn.toString() );
+        Assert.assertEquals( "a = #0010A0AAFF", dn.getName() );
+    }
+
+    /**
+     * test a simple DN with quoted attribute value : a = "quoted \"value"
+     */
+    public void testLdapDNQuotedAttributeValue() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = quoted \\\"value" );
+        Assert.assertEquals( "a=quoted \\\"value", dn.toString() );
+        Assert.assertEquals( "a = quoted \\\"value", dn.getName() );
+    }
+
+    // REMOVE operation -------------------------------------------------------
+    
+    /**
+     * test a remove from position 0
+     */
+    public void testLdapDNRemove0() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d, e=f" );
+        Assert.assertEquals( "e=f", dn.remove( 0 ).toString() );
+        Assert.assertEquals( "a=b,c=d", dn.toString() );
+        Assert.assertEquals( "a=b, c=d", dn.getName() );
+    }
+
+    /**
+     * test a remove from position 1
+     */
+    public void testLdapDNRemove1() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d, e=f" );
+        Assert.assertEquals( "c=d", dn.remove( 1 ).toString() );
+        Assert.assertEquals( "a=b, e=f", dn.getName() );
+    }
+    
+    /**
+     * test a remove from position 2
+     */
+    public void testLdapDNRemove2() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d, e=f" );
+        Assert.assertEquals( "a=b", dn.remove( 2 ).toString() );
+        Assert.assertEquals( " c=d, e=f", dn.getName() );
+    }
+
+    /**
+     * test a remove from position 1 whith semi colon
+     */
+    public void testLdapDNRemove1WithSemiColon() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d; e=f" );
+        Assert.assertEquals( "c=d", dn.remove( 1 ).toString() );
+        Assert.assertEquals( "a=b, e=f", dn.getName() );
+    }
+
+    /**
+     * test a remove out of bound
+     */
+    public void testLdapDNRemoveOutOfBound() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d; e=f" );
+        
+        try
+        {
+            dn.remove( 4 );
+            // We whould never reach this point
+            Assert.fail();
+        }
+        catch ( ArrayIndexOutOfBoundsException aoobe )
+        {
+            Assert.assertTrue( true );
+        }
+    }
+    
+    // SIZE operations
+    /**
+     * test a 0 size 
+     */
+    public void testLdapDNSize0() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN();
+        Assert.assertEquals( 0, dn.size() );
+    }
+
+    /**
+     * test a 1 size 
+     */
+    public void testLdapDNSize1() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b" );
+        Assert.assertEquals( 1, dn.size() );
+    }
+
+    /**
+     * test a 3 size 
+     */
+    public void testLdapDNSize3() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d, e=f" );
+        Assert.assertEquals( 3, dn.size() );
+    }
+
+    /**
+     * test a 3 size with NameComponents
+     */
+    public void testLdapDNSize3NC() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b+c=d, c=d, e=f" );
+        Assert.assertEquals( 3, dn.size() );
+    }
+
+    /**
+     * test size after operations
+     */
+    public void testLdapResizing() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN();
+        Assert.assertEquals( 0, dn.size() );
+        
+        dn.add( "e = f" );
+        Assert.assertEquals( 1, dn.size() );
+        
+        dn.add( "c = d" );
+        Assert.assertEquals( 2, dn.size() );
+
+        dn.remove( 0 );
+        Assert.assertEquals( 1, dn.size() );
+        
+        dn.remove( 0 );
+        Assert.assertEquals( 0, dn.size() );
+    }
+    
+    // ADD Operations
+    /**
+     * test Add on a new LdapDN
+     */
+    public void testLdapEmptyAdd() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN();
+        
+        dn.add( "e = f" );
+        Assert.assertEquals( "e=f" , dn.toString() );
+        Assert.assertEquals( "e = f" , dn.getName() );
+        Assert.assertEquals( 1, dn.size() );
+    }
+    
+    /**
+     * test Add to an existing LdapDN
+     */
+    public void testLdapDNAdd() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d");
+        
+        dn.add( "e = f" );
+        Assert.assertEquals( "e=f,a=b,c=d" , dn.toString() );
+        Assert.assertEquals( "e = f,a=b, c=d" , dn.getName() );
+        Assert.assertEquals( 3, dn.size() );
+    }
+
+    /**
+     * test Add a composite RDN to an existing LdapDN
+     */
+    public void testLdapDNAddComposite() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d");
+        
+        dn.add( "e = f + g = h" );
+        
+        // Warning ! The order of AVAs has changed during the parsing
+        // This has no impact on the correctness of the DN, but the
+        // String used to do the comparizon should be inverted.
+        Assert.assertEquals( "e=f+g=h,a=b,c=d" , dn.toString() );
+        Assert.assertEquals( 3, dn.size() );
+    }
+    
+    /**
+     * test Add at the end of an existing LdapDN
+     */
+    public void testLdapDNAddEnd() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d");
+        
+        dn.add( dn.size(), "e = f" );
+        Assert.assertEquals( "e = f,a=b, c=d" , dn.getName() );
+        Assert.assertEquals( 3, dn.size() );
+    }
+
+    /**
+     * test Add at the start of an existing LdapDN
+     */
+    public void testLdapDNAddStart() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d");
+        
+        dn.add( 0, "e = f" );
+        Assert.assertEquals( "a=b, c=d,e = f" , dn.getName() );
+        Assert.assertEquals( 3, dn.size() );
+    }
+
+    /**
+     * test Add at the middle of an existing LdapDN
+     */
+    public void testLdapDNAddMiddle() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d");
+        
+        dn.add( 1, "e = f" );
+        Assert.assertEquals( "a=b,e = f, c=d" , dn.getName() );
+        Assert.assertEquals( 3, dn.size() );
+    }
+
+    // ADD ALL Operations
+    /**
+     * Test AddAll 
+     * @throws InvalidNameException
+     */
+    public void testLdapDNAddAll() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b" );
+        LdapDN dn2 = new LdapDN( "c = d" );
+        dn.addAll( dn2 );
+        Assert.assertEquals( "c = d,a = b", dn.getName() );
+    }
+    
+    /**
+     * Test AddAll with an empty added name
+     * @throws InvalidNameException
+     */
+    public void testLdapDNAddAllAddedNameEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b" );
+        LdapDN dn2 = new LdapDN();
+        dn.addAll( dn2 );
+        Assert.assertEquals( "a=b", dn.toString() );
+        Assert.assertEquals( "a = b", dn.getName() );
+    }
+
+    /**
+     * Test AddAll to an empty name
+     * @throws InvalidNameException
+     */
+    public void testLdapDNAddAllNameEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN();
+        LdapDN dn2 = new LdapDN( "a = b" );
+        dn.addAll( dn2 );
+        Assert.assertEquals( "a = b", dn.getName() );
+    }
+    
+    /**
+     * Test AddAll at position 0
+     * @throws InvalidNameException
+     */
+    public void testLdapDNAt0AddAll() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b" );
+        LdapDN dn2 = new LdapDN( "c = d" );
+        dn.addAll( 0, dn2 );
+        Assert.assertEquals( "a = b,c = d", dn.getName() );
+    }
+    
+    /**
+     * Test AddAll at position 1
+     * @throws InvalidNameException
+     */
+    public void testLdapDNAt1AddAll() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b" );
+        LdapDN dn2 = new LdapDN( "c = d" );
+        dn.addAll( 1, dn2 );
+        Assert.assertEquals( "c = d,a = b", dn.getName() );
+    }
+    
+    /**
+     * Test AddAll at the middle
+     * @throws InvalidNameException
+     */
+    public void testLdapDNAtTheMiddleAddAll() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b, c = d" );
+        LdapDN dn2 = new LdapDN( "e = f" );
+        dn.addAll( 1, dn2 );
+        Assert.assertEquals( "a = b,e = f, c = d", dn.getName() );
+    }
+    
+    /**
+     * Test AddAll with an empty added name at position 0
+     * @throws InvalidNameException
+     */
+    public void testLdapDNAddAllAt0AddedNameEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b" );
+        LdapDN dn2 = new LdapDN();
+        dn.addAll( 0, dn2 );
+        Assert.assertEquals( "a=b", dn.toString() );
+        Assert.assertEquals( "a = b", dn.getName() );
+    }
+
+    /**
+     * Test AddAll to an empty name at position 0
+     * @throws InvalidNameException
+     */
+    public void testLdapDNAddAllAt0NameEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN();
+        LdapDN dn2 = new LdapDN( "a = b" );
+        dn.addAll( 0, dn2 );
+        Assert.assertEquals( "a = b", dn.getName() );
+    }
+    
+    // GET PREFIX actions
+    /**
+     * Get the prefix at pos 0 
+     */
+    public void testLdapDNGetPrefixPos0() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        LdapDN newDn = ((LdapDN)dn.getPrefix( 0 ));
+        Assert.assertEquals( "", newDn.getName() );
+    }
+
+    /**
+     * Get the prefix at pos 1 
+     */
+    public void testLdapDNGetPrefixPos1() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        LdapDN newDn = ((LdapDN)dn.getPrefix( 1 ));
+        Assert.assertEquals( "e = f", newDn.getName() );
+    }
+    
+    /**
+     * Get the prefix at pos 2 
+     */
+    public void testLdapDNGetPrefixPos2() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        LdapDN newDn = ((LdapDN)dn.getPrefix( 2 ));
+        Assert.assertEquals( " c=d,e = f", newDn.getName() );
+    }
+    
+    /**
+     * Get the prefix at pos 3 
+     */
+    public void testLdapDNGetPrefixPos3() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        LdapDN newDn = ((LdapDN)dn.getPrefix( 3 ));
+        Assert.assertEquals( "a=b, c=d,e = f", newDn.getName() );
+    }
+
+    /**
+     * Get the prefix out of bound 
+     */
+    public void testLdapDNGetPrefixPos4() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        
+        try
+        {
+            dn.getPrefix( 4 );
+            // We should not reach this point.
+            Assert.fail();
+        }
+        catch ( ArrayIndexOutOfBoundsException aoobe )
+        {
+            Assert.assertTrue( true );
+        }
+    }
+
+    /**
+     * Get the prefix of an empty LdapName
+     */
+    public void testLdapDNGetPrefixEmptyDN() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN();
+        LdapDN newDn = ((LdapDN)dn.getPrefix( 0 ));
+        Assert.assertEquals( "", newDn.getName() );
+    }
+    
+    // GET SUFFIX operations 
+    /**
+     * Get the suffix at pos 0 
+     */
+    public void testLdapDNGetSuffixPos0() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        LdapDN newDn = ((LdapDN)dn.getSuffix( 0 ));
+         Assert.assertEquals( "a=b, c=d,e = f", newDn.getName() );
+    }
+
+    /**
+     * Get the suffix at pos 1 
+     */
+    public void testLdapDNGetSuffixPos1() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        LdapDN newDn = ((LdapDN)dn.getSuffix( 1 ));
+        Assert.assertEquals( "a=b, c=d", newDn.getName() );
+    }
+    
+    /**
+     * Get the suffix at pos 2 
+     */
+    public void testLdapDNGetSuffixPos2() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        LdapDN newDn = ((LdapDN)dn.getSuffix( 2 ));
+        Assert.assertEquals( "a=b", newDn.getName() );
+    }
+    
+    /**
+     * Get the suffix at pos 3 
+     */
+    public void testLdapDNGetSuffixPos3() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        LdapDN newDn = ((LdapDN)dn.getSuffix( 3 ));
+        Assert.assertEquals( "", newDn.getName() );
+    }
+
+    /**
+     * Get the suffix out of bound 
+     */
+    public void testLdapDNGetSuffixPos4() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        
+        try
+        {
+            dn.getSuffix( 4 );
+            // We should not reach this point.
+            Assert.fail();
+        }
+        catch ( ArrayIndexOutOfBoundsException aoobe )
+        {
+            Assert.assertTrue( true );
+        }
+    }
+
+    /**
+     * Get the suffix of an empty LdapName
+     */
+    public void testLdapDNGetSuffixEmptyDN() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN();
+        LdapDN newDn = ((LdapDN)dn.getSuffix( 0 ));
+        Assert.assertEquals( "", newDn.getName() );
+    }
+    
+    // IS EMPTY operations
+    /**
+     * Test that a LdapDN is empty
+     */
+    public void testLdapDNIsEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN();
+        Assert.assertEquals( true, dn.isEmpty() );
+    }
+    
+    /**
+     * Test that a LdapDN is empty
+     */
+    public void testLdapDNNotEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b" );
+        Assert.assertEquals( false, dn.isEmpty() );
+    }
+
+    /**
+     * Test that a LdapDN is empty
+     */
+    public void testLdapDNRemoveIsEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d" );
+        dn.remove(0);
+        dn.remove(0);
+        
+        Assert.assertEquals( true, dn.isEmpty() );
+    }
+    
+    // STARTS WITH operations
+    /**
+     * Test a startsWith a null LdapDN
+     */
+    public void testLdapDNStartsWithNull() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( true, dn.startsWith( null ) );
+    }
+    
+    /**
+     * Test a startsWith an empty LdapDN
+     */
+    public void testLdapDNStartsWithEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( true, dn.startsWith( new LdapDN() ) );
+    }
+    
+    /**
+     * Test a startsWith an simple LdapDN
+     */
+    public void testLdapDNStartsWithSimple() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( true, dn.startsWith( new LdapDN( "e=f" ) ) );
+    }
+    
+    /**
+     * Test a startsWith a complex LdapDN
+     */
+    public void testLdapDNStartsWithComplex() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( true, dn.startsWith( new LdapDN( "c =  d, e =  f" ) ) );
+    }
+
+    /**
+     * Test a startsWith a complex LdapDN
+     */
+    public void testLdapDNStartsWithComplexMixedCase() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( false, dn.startsWith( new LdapDN( "c =  D, E =  f" ) ) );
+    }
+
+    /**
+     * Test a startsWith a full LdapDN
+     */
+    public void testLdapDNStartsWithFull() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( true, dn.startsWith( new LdapDN( "a=  b; c =  d, e =  f" ) ) );
+    }
+    
+    /**
+     * Test a startsWith which returns false
+     */
+    public void testLdapDNStartsWithWrong() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( false, dn.startsWith( new LdapDN( "c =  t, e =  f" ) ) );
+    }
+    
+    // ENDS WITH operations
+    /**
+     * Test a endsWith a null LdapDN
+     */
+    public void testLdapDNEndsWithNull() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( true, dn.endsWith( null ) );
+    }
+    
+    /**
+     * Test a endsWith an empty LdapDN
+     */
+    public void testLdapDNEndsWithEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( true, dn.endsWith( new LdapDN() ) );
+    }
+    
+    /**
+     * Test a endsWith an simple LdapDN
+     */
+    public void testLdapDNEndsWithSimple() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( true, dn.endsWith( new LdapDN( "a=b" ) ) );
+    }
+    
+    /**
+     * Test a endsWith a complex LdapDN
+     */
+    public void testLdapDNEndsWithComplex() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( true, dn.endsWith( new LdapDN( "a =  b, c =  d" ) ) );
+    }
+
+    /**
+     * Test a endsWith a complex LdapDN
+     */
+    public void testLdapDNEndsWithComplexMixedCase() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( false, dn.endsWith( new LdapDN( "a =  B, C =  d" ) ) );
+    }
+
+    /**
+     * Test a endsWith a full LdapDN
+     */
+    public void testLdapDNEndsWithFull() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( true, dn.endsWith( new LdapDN( "a=  b; c =  d, e =  f" ) ) );
+    }
+    
+    /**
+     * Test a endsWith which returns false
+     */
+    public void testLdapDNEndsWithWrong() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b, c=d,e = f" );
+        Assert.assertEquals( false, dn.endsWith( new LdapDN( "a =  b, e =  f" ) ) );
+    }
+    
+    // GET ALL operations
+    /**
+     * test a getAll operation on a null DN
+     */
+    public void testLdapDNGetAllNull() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN();
+        Enumeration nc = dn.getAll();
+        
+        Assert.assertEquals( false, nc.hasMoreElements() );
+    }
+
+    /**
+     * test a getAll operation on an empty DN
+     */
+    public void testLdapDNGetAllEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN("");
+        Enumeration nc = dn.getAll();
+        
+        Assert.assertEquals( false, nc.hasMoreElements() );
+    }
+    
+    /**
+     * test a getAll operation on a simple DN
+     */
+    public void testLdapDNGetAllSimple() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN("a=b");
+        Enumeration nc = dn.getAll();
+        
+        Assert.assertEquals( true, nc.hasMoreElements() );
+        Assert.assertEquals( "a=b", nc.nextElement() );
+        Assert.assertEquals( false, nc.hasMoreElements() );
+    }
+    
+    /**
+     * test a getAll operation on a complex DN
+     */
+    public void testLdapDNGetAllComplex() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "e=f+g=h,a=b,c=d" );
+        Enumeration nc = dn.getAll();
+        
+        Assert.assertEquals( true, nc.hasMoreElements() );
+        Assert.assertEquals( "c=d", nc.nextElement() );
+        Assert.assertEquals( true, nc.hasMoreElements() );
+        Assert.assertEquals( "a=b", nc.nextElement() );
+        Assert.assertEquals( true, nc.hasMoreElements() );
+        Assert.assertEquals( "e=f+g=h", nc.nextElement() );
+        Assert.assertEquals( false, nc.hasMoreElements() );
+    }
+    
+    /**
+     * test a getAll operation on a complex DN
+     */
+    public void testLdapDNGetAllComplexOrdered() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "g=h+e=f,a=b,c=d" );
+        Enumeration nc = dn.getAll();
+        
+        Assert.assertEquals( true, nc.hasMoreElements() );
+        Assert.assertEquals( "c=d", nc.nextElement() );
+        Assert.assertEquals( true, nc.hasMoreElements() );
+        Assert.assertEquals( "a=b", nc.nextElement() );
+        Assert.assertEquals( true, nc.hasMoreElements() );
+        
+        // The lowest atav should be the first one
+        Assert.assertEquals( "e=f+g=h", nc.nextElement() );
+        Assert.assertEquals( false, nc.hasMoreElements() );
+    }
+    
+    // CLONE Operation
+    /**
+     * test a clone operation on a empty DN
+     */
+    public void testLdapDNCloneEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN();
+        LdapDN clone = (LdapDN)dn.clone();
+        
+        Assert.assertEquals( "", clone.getName() );
+    }
+    
+    /**
+     * test a clone operation on a simple DN
+     */
+    public void testLdapDNCloneSimple() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a=b" );
+        LdapDN clone = (LdapDN)dn.clone();
+        
+        Assert.assertEquals( "a=b", clone.getName() );
+        dn.remove( 0 );
+        Assert.assertEquals( "a=b", clone.getName() );
+    }
+    
+    /**
+     * test a clone operation on a complex DN
+     */
+    public void testLdapDNCloneComplex() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "e=f+g=h,a=b,c=d" );
+        LdapDN clone = (LdapDN)dn.clone();
+        
+        Assert.assertEquals( "e=f+g=h,a=b,c=d", clone.getName() );
+        dn.remove( 2 );
+        Assert.assertEquals( "e=f+g=h,a=b,c=d", clone.getName() );
+    }
+    
+    // GET operations
+    /**
+     * test a get in a null DN
+     */
+    public void testLdapDNGetNull() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN();
+        Assert.assertEquals( "", dn.get( 0 ) );
+    }
+
+    /**
+     * test a get in an empty DN
+     */
+    public void testLdapDNGetEmpty() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "" );
+        Assert.assertEquals( "", dn.get( 0 ) );
+    }
+    
+    /**
+     * test a get in a simple DN
+     */
+    public void testLdapDNGetSimple() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b" );
+        Assert.assertEquals( "a=b", dn.get( 0 ) );
+    }
+    
+    /**
+     * test a get in a complex DN
+     */
+    public void testLdapDNGetComplex() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b + c= d, e= f; g =h" );
+        Assert.assertEquals( "g=h", dn.get( 0 ) );
+        Assert.assertEquals( "e=f", dn.get( 1 ) );
+        Assert.assertEquals( "a=b+c=d", dn.get( 2 ) );
+    }
+    
+    /**
+     * test a get out of bound
+     */
+    public void testLdapDNGetOutOfBound() throws InvalidNameException
+    {
+        LdapDN dn = new LdapDN( "a = b + c= d, e= f; g =h" );
+        
+        try
+        {
+            dn.get( 4 );
+            Assert.fail();
+        }
+        catch ( ArrayIndexOutOfBoundsException aioob )
+        {
+            Assert.assertTrue( true );
+        }
+    }
+    
+    /**
+     * Tests the examples from the JNDI tutorials to make sure LdapName behaves
+     * appropriately.  The example can be found online 
+     * <a href="">here</a>.
+     * 
+     * @throws Exception if anything goes wrong
+     */
+    public void testJNDITutorialExample()
+        throws Exception
+    {
+        // Parse the name
+        Name name = new LdapDN( "cn=John,ou=People,ou=Marketing" );
+        
+        // Remove the second component from the head: ou=People
+        String out = name.remove( 1 ).toString() ;
+        
+        // System.out.println( l_out ) ;
+        assertEquals( "ou=People", out ) ;
+
+        // Add to the head (first): cn=John,ou=Marketing,ou=East
+        out = name.add( 0, "ou=East" ).toString() ;
+        
+        assertEquals( "cn=John,ou=Marketing,ou=East", out ) ;
+        
+        // Add to the tail (last): cn=HomeDir,cn=John,ou=Marketing,ou=East
+        out = name.add( "cn=HomeDir" ).toString() ;
+        
+        assertEquals( "cn=HomeDir,cn=John,ou=Marketing,ou=East", out ) ;
+    }
+    
+    public void testAttributeEqualsIsCaseInSensitive() throws Exception
+    {
+        Name name1 = new LdapDN( "cn=HomeDir" );
+        Name name2 = new LdapDN( "CN=HomeDir" );
+
+        assertTrue( name1.equals( name2 ) );
+    }
+
+
+    public void testAttributeTypeEqualsIsCaseInsensitive() throws Exception
+    {
+        Name name1 = new LdapDN( "cn=HomeDir+cn=WorkDir" );
+        Name name2 = new LdapDN( "cn=HomeDir+CN=WorkDir" );
+
+        assertTrue( name1.equals( name2 ) );
+    }
+
+
+    public void testNameEqualsIsInsensitiveToAttributesOrder() throws Exception
+    {
+
+        Name name1 = new LdapDN( "cn=HomeDir+cn=WorkDir" );
+        Name name2 = new LdapDN( "cn=WorkDir+cn=HomeDir" );
+
+        assertTrue( name1.equals( name2 ) );
+    }
+
+
+    public void testAttributeComparisonIsCaseInSensitive() throws Exception
+    {
+        Name name1 = new LdapDN( "cn=HomeDir" );
+        Name name2 = new LdapDN( "CN=HomeDir" );
+
+        assertEquals( 0, name1.compareTo( name2 ) );
+    }
+
+
+    public void testAttributeTypeComparisonIsCaseInsensitive() throws Exception
+    {
+        Name name1 = new LdapDN( "cn=HomeDir+cn=WorkDir" );
+        Name name2 = new LdapDN( "cn=HomeDir+CN=WorkDir" );
+
+        assertEquals( 0, name1.compareTo( name2 ) );
+    }
+
+
+    public void testNameComparisonIsInsensitiveToAttributesOrder() throws Exception
+    {
+
+        Name name1 = new LdapDN( "cn=HomeDir+cn=WorkDir" );
+        Name name2 = new LdapDN( "cn=WorkDir+cn=HomeDir" );
+
+        assertEquals( 0, name1.compareTo( name2 ) );
+    }
+    
+    public void testNameComparisonIsInsensitiveToAttributesOrderFailure() throws Exception
+    {
+
+        Name name1 = new LdapDN( "cn= HomeDir+cn=Workdir" );
+        Name name2 = new LdapDN( "cn = Work+cn=HomeDir" );
+
+        assertEquals( 1, name1.compareTo( name2 ) );
+    }
+    
+    /**
+     * Test the encoding of a LdanDN
+     *
+     */
+    public void testNameToBytes() throws Exception
+    {
+        LdapDN dn = new LdapDN( "cn = John, ou = People, OU = Marketing" );
+        
+        byte[] bytes = dn.getBytes();
+        
+        Assert.assertEquals( 30, dn.getNbBytes() );
+        Assert.assertEquals("cn=John,ou=People,ou=Marketing", new String( bytes, "UTF-8" ) );
+    }
+    
+    public void testStringParser() throws Exception
+    {
+        Name name = DnParser.getNameParser().parse( "CN = Emmanuel  Lécharny" );
+        
+        Assert.assertEquals( "CN = Emmanuel  Lécharny", ((LdapDN)name).getName() );
+        Assert.assertEquals( "cn=Emmanuel  Lécharny", name.toString() );
+    }
+    
+    /**
+     * @throws Exception if anything goes wrong. 
+     */
+    public void testHashCode() 
+        throws Exception
+    {
+        String strName = "cn=HomeDir,cn=John,ou=Marketing,ou=East" ;
+        Name name = new LdapDN( strName ) ;
+        assertEquals( name.hashCode(), strName.hashCode() ) ;
+    }
+
+
+    /**
+     * Class to test for void LdapName(String)
+     * @throws Exception if anything goes wrong.
+     */
+    public void testLdapNameString() 
+        throws Exception
+    {
+        Name name = new LdapDN( "" ) ;
+        Name name50 = new LdapDN() ; 
+        assertEquals( name50, name ) ;
+        
+        Name name0 = new LdapDN( "ou=Marketing,ou=East" ) ;
+        Name copy =  new LdapDN( "ou=Marketing,ou=East" ) ;
+        Name name1 = new LdapDN( "cn=John,ou=Marketing,ou=East" ) ;
+        Name name2 = new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        Name name3 = new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=West" ) ;
+        Name name4 = new LdapDN( "cn=Website,cn=John,ou=Marketing,ou=West" ) ;
+        Name name5 = new LdapDN( "cn=Airline,cn=John,ou=Marketing,ou=West" ) ;
+            
+        assertTrue( name0.compareTo( copy ) == 0 ) ;
+        assertTrue( name0.compareTo( name1 ) < 0 ) ;
+        assertTrue( name0.compareTo( name2 ) < 0 ) ;
+        assertTrue( name1.compareTo( name2 ) < 0 ) ;
+        assertTrue( name2.compareTo( name1 ) > 0 ) ;
+        assertTrue( name2.compareTo( name0 ) > 0 ) ;
+        assertTrue( name2.compareTo( name3 ) < 0 ) ;
+        assertTrue( name2.compareTo( name4 ) < 0 ) ;
+        assertTrue( name3.compareTo( name4 ) < 0 ) ;
+        assertTrue( name3.compareTo( name5 ) > 0 ) ;
+        assertTrue( name4.compareTo( name5 ) > 0 ) ;
+        assertTrue( name2.compareTo( name5 ) < 0 ) ;
+    }
+
+
+    /**
+     * Class to test for void LdapName()
+     */
+    public void testLdapName() 
+    {
+        Name name = new LdapDN() ;
+        assertTrue( name.toString().equals( "" ) ) ;
+    }
+
+
+    /**
+     * Class to test for void LdapName(List)
+     */
+    public void testLdapNameList() throws InvalidNameException
+    {
+        ArrayList list = new ArrayList() ;
+        list.add( "ou=People" ) ;
+        list.add( "dc=example" ) ;
+        list.add( "dc=com" ) ;
+        Name name = new LdapDN( list ) ;
+        assertTrue( name.toString().equals( 
+            "ou=People,dc=example,dc=com" ) ) ;
+    }
+
+
+    /**
+     * Class to test for void LdapName(Iterator)
+     */
+    public void testLdapNameIterator() throws InvalidNameException
+    {
+        ArrayList list = new ArrayList() ;
+        list.add( "ou=People" ) ;
+        list.add( "dc=example" ) ;
+        list.add( "dc=com" ) ;
+        Name name = new LdapDN( list.iterator() ) ;
+        assertTrue( name.toString().equals( 
+            "ou=People,dc=example,dc=com" ) ) ;
+    }
+
+
+    /**
+     * Class to test for Object clone()
+     * @throws Exception if anything goes wrong. 
+     */
+    public void testClone()
+        throws Exception 
+    {
+        String strName = "cn=HomeDir,cn=John,ou=Marketing,ou=East" ;
+        Name name = new LdapDN( strName ) ;
+        assertEquals( name, name.clone() ) ;
+    }
+
+
+    /**
+     * Class to test for compareTo 
+     * @throws Exception if anything goes wrong. 
+     */
+    public void testCompareTo()
+        throws Exception 
+    {
+        Name name0 = 
+            new LdapDN( "ou=Marketing,ou=East" ) ;
+        Name copy = 
+            new LdapDN( "ou=Marketing,ou=East" ) ;
+        Name name1 = 
+            new LdapDN( "cn=John,ou=Marketing,ou=East" ) ;
+        Name name2 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        Name name3 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=West" ) ;
+        Name name4 = 
+            new LdapDN( "cn=Website,cn=John,ou=Marketing,ou=West" ) ;
+        Name name5 = 
+            new LdapDN( "cn=Airline,cn=John,ou=Marketing,ou=West" ) ;
+            
+        assertTrue( name0.compareTo( copy ) == 0 ) ;
+        assertTrue( name0.compareTo( name1 ) < 0 ) ;
+        assertTrue( name0.compareTo( name2 ) < 0 ) ;
+        assertTrue( name1.compareTo( name2 ) < 0 ) ;
+        assertTrue( name2.compareTo( name1 ) > 0 ) ;
+        assertTrue( name2.compareTo( name0 ) > 0 ) ;
+        assertTrue( name2.compareTo( name3 ) < 0 ) ;
+        assertTrue( name2.compareTo( name4 ) < 0 ) ;
+        assertTrue( name3.compareTo( name4 ) < 0 ) ;
+        assertTrue( name3.compareTo( name5 ) > 0 ) ;
+        assertTrue( name4.compareTo( name5 ) > 0 ) ;
+        assertTrue( name2.compareTo( name5 ) < 0 ) ;
+        
+        List list = new ArrayList() ;
+        
+        Comparator comparator = new Comparator()
+        {
+            public int compare( Object obj1, Object obj2 ) 
+            {
+                Name name1 = ( LdapDN ) obj1 ;
+                Name name2 = ( LdapDN ) obj2 ;
+                return name1.compareTo( name2 ) ;
+            }
+            
+            public boolean equals( Object obj ) 
+            {
+                return super.equals( obj ) ;
+            }
+            
+            
+            public int hashCode()
+            {
+                return super.hashCode() ;
+            }
+        } ;
+        
+        list.add( name0 ) ;
+        list.add( name1 ) ;
+        list.add( name2 ) ;
+        list.add( name3 ) ;
+        list.add( name4 ) ;
+        list.add( name5 ) ;
+        Collections.sort( list, comparator ) ;
+        
+        assertEquals( name0, list.get( 0 ) ) ;
+        assertEquals( name1, list.get( 1 ) ) ;
+        assertEquals( name2, list.get( 2 ) ) ;
+        assertEquals( name5, list.get( 3 ) ) ;
+        assertEquals( name3, list.get( 4 ) ) ;
+        assertEquals( name4, list.get( 5 ) ) ;
+    }
+
+
+    /**
+     * Class to test for size 
+     * @throws Exception if anything goes wrong. 
+     */
+    public void testSize() 
+        throws Exception
+    {
+        Name name0 =
+            new LdapDN( "" ) ;
+        Name name1 =
+            new LdapDN( "ou=East" ) ;
+        Name name2 =
+            new LdapDN( "ou=Marketing,ou=East" ) ;
+        Name name3 =
+            new LdapDN( "cn=John,ou=Marketing,ou=East" ) ;
+        Name name4 =
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        Name name5 =
+            new LdapDN( 
+                "cn=Website,cn=HomeDir,cn=John,ou=Marketing,ou=West" ) ;
+        Name name6 =
+            new LdapDN( 
+                "cn=Airline,cn=Website,cn=HomeDir,cn=John,ou=Marketing,ou=West"
+                ) ;
+                
+        assertEquals( 0, name0.size() ) ;
+        assertEquals( 1, name1.size() ) ;
+        assertEquals( 2, name2.size() ) ;
+        assertEquals( 3, name3.size() ) ;
+        assertEquals( 4, name4.size() ) ;
+        assertEquals( 5, name5.size() ) ;
+        assertEquals( 6, name6.size() ) ;
+    }
+
+
+    /**
+     * Class to test for isEmpty 
+     * @throws Exception if anything goes wrong. 
+     */
+    public void testIsEmpty() 
+        throws Exception
+    {
+        Name name0 =
+            new LdapDN( "" ) ;
+        Name name1 =
+            new LdapDN( "ou=East" ) ;
+        Name name2 =
+            new LdapDN( "ou=Marketing,ou=East" ) ;
+        Name name3 =
+            new LdapDN( "cn=John,ou=Marketing,ou=East" ) ;
+        Name name4 =
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        Name name5 =
+            new LdapDN( 
+                "cn=Website,cn=HomeDir,cn=John,ou=Marketing,ou=West" ) ;
+        Name name6 =
+            new LdapDN( 
+                "cn=Airline,cn=Website,cn=HomeDir,cn=John,ou=Marketing,ou=West"
+                ) ;
+                
+        assertEquals( true, name0.isEmpty() ) ;
+        assertEquals( false, name1.isEmpty() ) ;
+        assertEquals( false, name2.isEmpty() ) ;
+        assertEquals( false, name3.isEmpty() ) ;
+        assertEquals( false, name4.isEmpty() ) ;
+        assertEquals( false, name5.isEmpty() ) ;
+        assertEquals( false, name6.isEmpty() ) ;
+    }
+
+
+    /**
+     * Class to test for getAll
+     * @throws Exception if anything goes wrong. 
+     */
+    public void testGetAll() 
+        throws Exception
+    {
+        Name name0 = new LdapDN( "" ) ;
+        Name name1 = new LdapDN( "ou=East" ) ;
+        Name name2 = new LdapDN( "ou=Marketing,ou=East" ) ;
+        Name name3 = new LdapDN( "cn=John,ou=Marketing,ou=East" ) ;
+        Name name4 = new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        Name name5 = new LdapDN( "cn=Website,cn=HomeDir,cn=John,ou=Marketing,ou=West" ) ;
+        Name name6 = new LdapDN( "cn=Airline,cn=Website,cn=HomeDir,cn=John,ou=Marketing,ou=West" ) ;
+                
+        Enumeration enum0 = name0.getAll() ;
+        assertEquals( false, enum0.hasMoreElements() ) ; 
+        
+        Enumeration enum1 = name1.getAll() ;
+        assertEquals( true, enum1.hasMoreElements() ) ;
+        
+        for ( int i = 0 ; enum1.hasMoreElements(); i++ ) 
+        {
+            String element = ( String ) enum1.nextElement() ;
+            
+            if ( i == 0 ) 
+            {
+                assertEquals( "ou=East", element ) ;
+            }
+        }
+        
+        Enumeration enum2 = name2.getAll() ;
+        assertEquals( true, enum2.hasMoreElements() ) ; 
+        
+        for ( int i = 0 ; enum2.hasMoreElements(); i++ ) 
+        {
+        	String element = ( String ) enum2.nextElement() ;
+            
+            if ( i == 0 ) 
+            {
+                assertEquals( "ou=East", element.toString() ) ;
+            }
+            
+            if ( i == 1 ) 
+            {
+                assertEquals( "ou=Marketing", element.toString() ) ;
+            }
+        }
+                
+        Enumeration enum3 = name3.getAll() ;
+        assertEquals( true, enum3.hasMoreElements() ) ; 
+        
+        for ( int i = 0 ; enum3.hasMoreElements(); i++ ) 
+        {
+        	String element = ( String ) enum3.nextElement() ;
+            
+            if ( i == 0 ) 
+            {
+                assertEquals( "ou=East", element.toString() ) ;
+            }
+            
+            if ( i == 1 ) 
+            {
+                assertEquals( "ou=Marketing", element.toString() ) ;
+            }
+            
+            if ( i == 2 ) 
+            {
+                assertEquals( "cn=John", element.toString() ) ;
+            }
+        }
+        
+        Enumeration enum4 = name4.getAll() ;
+        assertEquals( true, enum4.hasMoreElements() ) ; 
+        
+        for ( int i = 0 ; enum4.hasMoreElements(); i++ ) 
+        {
+        	String element = ( String ) enum4.nextElement() ;
+            
+            if ( i == 0 ) 
+            {
+                assertEquals( "ou=East", element.toString() ) ;
+            }
+            
+            if ( i == 1 ) 
+            {
+                assertEquals( "ou=Marketing", element.toString() ) ;
+            }
+            
+            if ( i == 2 ) 
+            {
+                assertEquals( "cn=John", element.toString() ) ;
+            }
+            
+            if ( i == 3 ) 
+            {
+                assertEquals( "cn=HomeDir", element.toString() ) ;
+            }
+        }
+        
+        Enumeration enum5 = name5.getAll() ;
+        assertEquals( true, enum5.hasMoreElements() ) ; 
+        
+        for ( int i = 0 ; enum5.hasMoreElements(); i++ ) 
+        {
+        	String element = ( String ) enum5.nextElement() ;
+            
+            if ( i == 0 ) 
+            {
+                assertEquals( "ou=West", element.toString() ) ;
+            }
+            
+            if ( i == 1 ) 
+            {
+                assertEquals( "ou=Marketing", element.toString() ) ;
+            }
+            
+            if ( i == 2 ) 
+            {
+                assertEquals( "cn=John", element.toString() ) ;
+            }
+            
+            if ( i == 3 ) 
+            {
+                assertEquals( "cn=HomeDir", element.toString() ) ;
+            }
+            
+            if ( i == 4 ) 
+            {
+                assertEquals( "cn=Website", element.toString() ) ;
+            }
+        }
+                
+        Enumeration enum6 = name6.getAll() ;
+        assertEquals( true, enum6.hasMoreElements() ) ; 
+        
+        for ( int i = 0 ; enum6.hasMoreElements(); i++ ) 
+        {
+        	String element = ( String ) enum6.nextElement() ;
+            
+            if ( i == 0 ) 
+            {
+                assertEquals( "ou=West", element.toString() ) ;
+            }
+            
+            if ( i == 1 ) 
+            {
+                assertEquals( "ou=Marketing", element.toString() ) ;
+            }
+            
+            if ( i == 2 ) 
+            {
+                assertEquals( "cn=John", element.toString() ) ;
+            }
+            
+            if ( i == 3 ) 
+            {
+                assertEquals( "cn=HomeDir", element.toString() ) ;
+            }
+            
+            if ( i == 4 ) 
+            {
+                assertEquals( "cn=Website", element.toString() ) ;
+            }
+            
+            if ( i == 5 ) 
+            {
+                assertEquals( "cn=Airline", element.toString() ) ;
+            }
+        }
+    }
+
+    /**
+     * Class to test for getAllRdn
+     * @throws Exception if anything goes wrong. 
+     */
+    public void testGetAllRdn() 
+        throws Exception
+    {
+        LdapDN name = new LdapDN( "cn=Airline,cn=Website,cn=HomeDir,cn=John,ou=Marketing,ou=West" ) ;
+                        
+        Enumeration rdns = name.getAllRdn() ;
+        assertEquals( true, rdns.hasMoreElements() ) ; 
+        
+        for ( int i = 0 ; rdns.hasMoreElements(); i++ ) 
+        {
+        	Rdn element = ( Rdn ) rdns.nextElement() ;
+            
+            if ( i == 0 ) 
+            {
+                assertEquals( "ou=West", element.toString() ) ;
+            }
+            
+            if ( i == 1 ) 
+            {
+                assertEquals( "ou=Marketing", element.toString() ) ;
+            }
+            
+            if ( i == 2 ) 
+            {
+                assertEquals( "cn=John", element.toString() ) ;
+            }
+            
+            if ( i == 3 ) 
+            {
+                assertEquals( "cn=HomeDir", element.toString() ) ;
+            }
+            
+            if ( i == 4 ) 
+            {
+                assertEquals( "cn=Website", element.toString() ) ;
+            }
+            
+            if ( i == 5 ) 
+            {
+                assertEquals( "cn=Airline", element.toString() ) ;
+            }
+        }
+    }
+
+
+    /**
+     * Class to test for get
+     * @throws Exception anything goes wrong
+     */
+    public void testGet() 
+        throws Exception
+    {
+        Name name = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        assertEquals( "cn=HomeDir", name.get( 3 ) ) ;
+        assertEquals( "cn=John", name.get( 2 ) ) ;
+        assertEquals( "ou=Marketing", name.get( 1 ) ) ;
+        assertEquals( "ou=East", name.get( 0 ) ) ;
+    }
+
+
+    /**
+     * Class to test for getSuffix
+     * @throws Exception anything goes wrong
+     */
+    public void testGetXSuffix()
+        throws Exception
+    {
+        Name name = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        assertEquals( "", name.getSuffix( 4 ).toString() ) ;
+        assertEquals( "cn=HomeDir", name.getSuffix( 3 ).toString() ) ;
+        assertEquals( "cn=HomeDir,cn=John", 
+            name.getSuffix( 2 ).toString() ) ;
+        assertEquals( "cn=HomeDir,cn=John,ou=Marketing", 
+            name.getSuffix( 1 ).toString() ) ;
+        assertEquals( "cn=HomeDir,cn=John,ou=Marketing,ou=East", 
+            name.getSuffix( 0 ).toString() ) ;
+    }
+
+
+    /**
+     * Class to test for getPrefix
+     * @throws Exception anything goes wrong
+     */
+    public void testGetPrefix()
+        throws Exception
+    {
+        Name name = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        
+        assertEquals( "cn=HomeDir,cn=John,ou=Marketing,ou=East", 
+            name.getPrefix( 4 ).toString() ) ;
+        assertEquals( "cn=John,ou=Marketing,ou=East", 
+            name.getPrefix( 3 ).toString() ) ;
+        assertEquals( "ou=Marketing,ou=East", 
+            name.getPrefix( 2 ).toString() ) ;
+        assertEquals( "ou=East", 
+            name.getPrefix( 1 ).toString() ) ;
+        assertEquals( "", 
+            name.getPrefix( 0 ).toString() ) ;
+    }
+
+    /**
+     * Class to test for startsWith
+     * @throws Exception anything goes wrong
+     */
+    public void testStartsWith()
+        throws Exception 
+    {
+        Name name0 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        Name name1 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        Name name2 = 
+            new LdapDN( "cn=John,ou=Marketing,ou=East" ) ;
+        Name name3 = 
+            new LdapDN( "ou=Marketing,ou=East" ) ;
+        Name name4 = 
+            new LdapDN( "ou=East" ) ;
+        Name name5 = 
+            new LdapDN( "" ) ;
+
+        Name name6 = 
+            new LdapDN( "cn=HomeDir" ) ;
+        Name name7 = 
+            new LdapDN( "cn=HomeDir,cn=John" ) ;
+        Name name8 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing" ) ;
+                        
+        assertTrue( name0.startsWith( name1 ) ) ;
+        assertTrue( name0.startsWith( name2 ) ) ;
+        assertTrue( name0.startsWith( name3 ) ) ;
+        assertTrue( name0.startsWith( name4 ) ) ;
+        assertTrue( name0.startsWith( name5 ) ) ;
+        
+        assertTrue( ! name0.startsWith( name6 ) ) ;
+        assertTrue( ! name0.startsWith( name7 ) ) ;
+        assertTrue( ! name0.startsWith( name8 ) ) ;
+    }
+
+
+    /**
+     * Class to test for endsWith
+     * @throws Exception anything goes wrong
+     */
+    public void testEndsWith() 
+        throws Exception 
+    {
+        Name name0 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        Name name1 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        Name name2 = 
+            new LdapDN( "cn=John,ou=Marketing,ou=East" ) ;
+        Name name3 = 
+            new LdapDN( "ou=Marketing,ou=East" ) ;
+        Name name4 = 
+            new LdapDN( "ou=East" ) ;
+        Name name5 = 
+            new LdapDN( "" ) ;
+
+        Name name6 = 
+            new LdapDN( "cn=HomeDir" ) ;
+        Name name7 = 
+            new LdapDN( "cn=HomeDir,cn=John" ) ;
+        Name name8 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing" ) ;
+                        
+        assertTrue( name0.endsWith( name1 ) ) ;
+        assertTrue( ! name0.endsWith( name2 ) ) ;
+        assertTrue( ! name0.endsWith( name3 ) ) ;
+        assertTrue( ! name0.endsWith( name4 ) ) ;
+        assertTrue( name0.endsWith( name5 ) ) ;
+        
+        assertTrue( name0.endsWith( name6 ) ) ;
+        assertTrue( name0.endsWith( name7 ) ) ;
+        assertTrue( name0.endsWith( name8 ) ) ;
+
+        /*
+        Hashtable env = new Hashtable() ;
+        env.put( Context.SECURITY_AUTHENTICATION, "simple" ) ;
+        env.put( Context.SECURITY_PRINCIPAL, "cn=admin,dc=example,dc=com" ) ;
+        env.put( Context.SECURITY_CREDENTIALS, "jPasswordField1" ) ;
+        env.put( Context.INITIAL_CONTEXT_FACTORY, 
+            "com.sun.jndi.ldap.LdapCtxFactory" ) ;
+        env.put( Context.PROVIDER_URL, 
+            "ldap://localhost:1396/dc=example,dc=com" ) ;
+        DirContext ctx = new InitialDirContext( env ) ;
+        NamingEnumeration enum = ctx.listBindings( "" ) ;
+        Name name0 = 
+            new LdapDN( "ou=Special Users,dc=example,dc=com" ) ;
+        Name name1 = 
+            new LdapDN( "dc=example,dc=com" ) ;
+        Name name2 = 
+            new LdapDN( "dc=com" ) ;
+        Name name3 = 
+            new LdapDN( "ou=Special Users" ) ;
+        Name name4 = 
+            new LdapDN( "ou=Special Users,dc=example" ) ;
+        Name name5 = 
+            new LdapDN( "" ) ;
+        while ( enum.hasMore() )
+        {
+            Binding binding = ( Binding ) enum.next() ;
+            DirContext dirCtx = ( DirContext ) binding.getObject() ;
+            NameParser parser = dirCtx.getNameParser( "" ) ;
+            Name namex = parser.parse( dirCtx.getNameInNamespace() ) ;
+            // DirContext dirCtx = ( DirContext ) enum.next() ;
+        }
+        */
+    }
+
+
+    /**
+     * Class to test for Name addAll(Name)
+     * @throws Exception when anything goes wrong
+     */
+    public void testAddAllName0()
+        throws Exception 
+    {
+        Name name = new LdapDN() ;
+        Name name0 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        assertTrue( name0.equals( name.addAll( name0 ) ) ) ;
+    }
+
+    /**
+     * Class to test for Name addAll(Name)
+     * @throws Exception when anything goes wrong
+     */
+    public void testAddAllNameExisting0()
+        throws Exception 
+    {
+        Name name1 = new LdapDN( "ou=Marketing,ou=East" );
+        Name name2 = new LdapDN( "cn=HomeDir,cn=John" );
+        Name nameAdded = new LdapDN( "cn=HomeDir,cn=John, ou=Marketing,ou=East" );
+        assertTrue( nameAdded.equals( name1.addAll( name2 ) ) ) ;
+    }
+
+
+    /**
+     * Class to test for Name addAll(Name)
+     * @throws Exception when anything goes wrong
+     */
+    public void testAddAllName1()
+        throws Exception 
+    {
+        Name name = new LdapDN() ;
+        Name name0 = 
+            new LdapDN( "ou=Marketing,ou=East" ) ;
+        Name name1 = 
+            new LdapDN( "cn=HomeDir,cn=John" ) ;
+        Name name2 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+            
+        assertTrue( name0.equals( name.addAll( name0 ) ) ) ;
+        assertTrue( name2.equals( name.addAll( name1 ) ) ) ;
+    }
+    
+    
+    /**
+     * Class to test for Name addAll(int, Name)
+     * @throws Exception when something goes wrong
+     */
+    public void testAddAllintName0()
+        throws Exception 
+    {
+        Name name = new LdapDN() ;
+        Name name0 = 
+            new LdapDN( "ou=Marketing,ou=East" ) ;
+        Name name1 = 
+            new LdapDN( "cn=HomeDir,cn=John" ) ;
+        Name name2 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+            
+        assertTrue( name0.equals( name.addAll( name0 ) ) ) ;
+        assertTrue( name2.equals( name.addAll( 2, name1 ) ) ) ;
+    }
+
+
+    /**
+     * Class to test for Name addAll(int, Name)
+     * @throws Exception when something goes wrong
+     */
+    public void testAddAllintName1()
+        throws Exception 
+    {
+        Name name = new LdapDN() ;
+        Name name0 = 
+            new LdapDN( "cn=HomeDir,ou=Marketing,ou=East" ) ;
+        Name name1 = 
+            new LdapDN( "cn=John" ) ;
+        Name name2 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+            
+        assertTrue( name0.equals( name.addAll( name0 ) ) ) ;
+        assertTrue( name2.equals( name.addAll( 2, name1 ) ) ) ;
+
+        Name name3 = 
+            new LdapDN( "cn=Airport" ) ;
+        Name name4 = 
+            new LdapDN( 
+            "cn=Airport,cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+            
+        assertTrue( name4.equals( name.addAll( 4, name3 ) ) ) ;
+
+        Name name5 = 
+            new LdapDN( "cn=ABC123" ) ;
+        Name name6 = 
+            new LdapDN( 
+            "cn=Airport,cn=HomeDir,cn=ABC123,cn=John,ou=Marketing,ou=East" ) ;
+        
+        assertTrue( name6.equals( name.addAll( 3, name5 ) ) ) ;
+    }
+
+
+    /**
+     * Class to test for Name add(String)
+     * @throws Exception when something goes wrong
+     */
+    public void testAddString()
+        throws Exception 
+    {
+        Name name = new LdapDN() ;
+        assertEquals( name, new LdapDN( "" ) ) ;
+        
+        Name name4 = 
+            new LdapDN( "ou=East" ) ;
+        name.add( "ou=East" ) ;
+        assertEquals( name4, name ) ;
+
+        Name name3 = 
+            new LdapDN( "ou=Marketing,ou=East" ) ;
+        name.add( "ou=Marketing" ) ;
+        assertEquals( name3, name ) ;
+         
+        Name name2 = 
+            new LdapDN( "cn=John,ou=Marketing,ou=East" ) ;
+        name.add( "cn=John" ) ;
+        assertEquals( name2, name ) ;
+
+        Name name0 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        name.add( "cn=HomeDir" ) ;
+        assertEquals( name0, name ) ;
+    }
+
+
+    /**
+     * Class to test for Name add(int, String)
+     * @throws Exception if anything goes wrong
+     */
+    public void testAddintString() 
+        throws Exception 
+    {
+        Name name = new LdapDN() ;
+        assertEquals( name, new LdapDN( "" ) ) ;
+        
+        Name name4 = 
+            new LdapDN( "ou=East" ) ;
+        name.add( "ou=East" ) ;
+        assertEquals( name4, name ) ;
+
+        Name name3 = 
+            new LdapDN( "ou=Marketing,ou=East" ) ;
+        name.add( 1, "ou=Marketing" ) ;
+        assertEquals( name3, name ) ;
+         
+        Name name2 = 
+            new LdapDN( "cn=John,ou=Marketing,ou=East" ) ;
+        name.add( 2, "cn=John" ) ;
+        assertEquals( name2, name ) ;
+
+        Name name0 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East" ) ;
+        name.add( 3, "cn=HomeDir" ) ;
+        assertEquals( name0, name ) ;
+        
+        Name name5 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East,o=LL "
+                + "Bean Inc." ) ;
+        name.add( 0, "o=LL Bean Inc." ) ;
+        assertEquals( name5, name ) ;
+        
+        Name name6 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Marketing,ou=East,c=US,o=LL "
+                + "Bean Inc." ) ;
+        name.add( 1, "c=US" ) ;
+        assertEquals( name6, name ) ;
+        
+        Name name7 = 
+            new LdapDN( "cn=HomeDir,cn=John,ou=Advertising,ou=Marketing,"
+                + "ou=East,c=US,o=LL "
+                + "Bean Inc." ) ;
+        name.add( 4, "ou=Advertising" ) ;
+        assertEquals( name7, name ) ;
+    }
+
+
+    /**
+     * Class to test for remove
+     * @throws Exception if anything goes wrong
+     */
+    public void testRemove() 
+        throws Exception 
+    {
+        Name name = new LdapDN() ;
+        assertEquals( new LdapDN( "" ), name ) ;
+            
+        Name name3 =
+            new LdapDN( "ou=Marketing" ) ;
+        name.add( "ou=East" ) ;
+        name.add( 1, "ou=Marketing" ) ;
+        name.remove( 0 ) ;
+        assertEquals( name3, name ) ;
+             
+        Name name2 = 
+            new LdapDN( "cn=HomeDir,ou=Marketing,ou=East" ) ;
+        name.add( 0, "ou=East" ) ;
+        name.add( 2, "cn=John" ) ;
+        name.add( "cn=HomeDir" ) ;
+        name.remove( 2 ) ;
+        assertEquals( name2, name ) ;
+
+        name.remove( 1 ) ;
+        Name name1 = 
+            new LdapDN( "cn=HomeDir,ou=East" ) ;
+        assertEquals( name1, name ) ;
+            
+        name.remove( 1 ) ;
+        Name name0 = 
+            new LdapDN( "ou=East" ) ;
+        assertEquals( name0, name ) ;
+        
+        name.remove( 0 ) ;
+        assertEquals( new LdapDN( "" ), name ) ;
+    }
+
+
+    /**
+     * Class to test for String toString()
+     * @throws Exception if anything goes wrong
+     */
+    public void testToString()
+        throws Exception  
+    {
+        Name name = new LdapDN() ;
+        assertEquals( "", name.toString() ) ;
+        
+        name.add( "ou=East" ) ;
+        assertEquals( "ou=East", name.toString() ) ;
+        
+        name.add( 1, "ou=Marketing" ) ;
+        assertEquals( "ou=Marketing,ou=East", name.toString() ) ;
+
+        name.add( "cn=John" ) ;
+        assertEquals( "cn=John,ou=Marketing,ou=East", name.toString() ) ;
+
+        name.add( "cn=HomeDir" ) ;
+        assertEquals( "cn=HomeDir,cn=John,ou=Marketing,ou=East", 
+            name.toString() ) ;
+    }
+
+
+    /**
+     * Class to test for boolean equals(Object)
+     * @throws Exception if anything goes wrong
+     */
+    public void testEqualsObject()
+        throws Exception 
+    {
+        assertTrue( new LdapDN( "ou=People" ).equals( new LdapDN( "ou=People" ) ) ) ;
+        
+        assertTrue( ! new LdapDN( "ou=People,dc=example,dc=com" ).equals( new LdapDN( "ou=People" ) ) ) ; 
+        assertTrue( ! new LdapDN( "ou=people" ).equals( new LdapDN( "ou=People" ) ) ) ; 
+        assertTrue( ! new LdapDN( "ou=Groups" ).equals( new LdapDN( "ou=People" ) ) ) ; 
+    }
+
+
+    public void testNameFrenchChars() throws Exception
+    {
+        String cn = new String(
+                new byte[] { 'c', 'n', '=', 0x4A, (byte) 0xC3, (byte) 0xA9, 0x72, (byte) 0xC3, (byte) 0xB4, 0x6D, 0x65 });
+
+        Name name = new LdapDN( cn);
+        
+        assertEquals( cn, name.toString() );
+    }
+
+    public void testNameGermanChars() throws Exception
+    {
+        String cn = new String(new byte[]{'c', 'n', '=', (byte)0xC3, (byte)0x84, (byte)0xC3, (byte)0x96, (byte)0xC3, 
+                    (byte)0x9C, (byte)0xC3, (byte)0x9F, (byte)0xC3, (byte)0xA4, (byte)0xC3, (byte)0xB6, (byte)0xC3, (byte)0xBC}, "UTF-8");
+
+        Name name = new LdapDN( cn );
+        
+        assertEquals( cn, name.toString() );
+    }
+
+    public void testNameTurkishChars() throws Exception
+    {
+        String cn = new String(new byte[]{'c', 'n', '=', (byte)0xC4, (byte)0xB0, (byte)0xC4, (byte)0xB1, 
+                (byte)0xC5, (byte)0x9E, (byte)0xC5, (byte)0x9F, 
+                (byte)0xC3, (byte)0x96, (byte)0xC3, (byte)0xB6, 
+                (byte)0xC3, (byte)0x9C, (byte)0xC3, (byte)0xBC, 
+                (byte)0xC4, (byte)0x9E, (byte)0xC4, (byte)0x9F }, "UTF-8");
+
+        Name name = new LdapDN( cn);
+        
+        assertEquals( cn, name.toString() );
+    }
+
+    /**
+     * Class to test for toOid( Name, Map)
+     */
+    public void testLdapNameToOid() throws Exception
+    {
+        ArrayList list = new ArrayList() ;
+        list.add( "ou= Some   People   " ) ;
+        list.add( "dc = eXample" ) ;
+        list.add( "dc= cOm" ) ;
+        Name name = new LdapDN( list.iterator() ) ;
+        
+        Map oids = new HashMap();
+        
+        oids.put( "dc", new OidNormalizer( "0.9.2342.19200300.100.1.25", new  DeepTrimToLowerNormalizer() ) );
+        oids.put( "ou", new OidNormalizer( "2.5.4.11", new  DeepTrimToLowerNormalizer() ) );
+        
+        Name result = LdapDN.toOidName( name, oids );
+        
+        assertTrue( result.toString().equals( 
+            "2.5.4.11=some people,0.9.2342.19200300.100.1.25=example,0.9.2342.19200300.100.1.25=com" ) ) ;
+        assertTrue( ( (LdapDN)result).toUpName().equals( "ou= Some   People   ,dc = eXample,dc= cOm" ) );
+    }
+
+    /**
+     * Class to test for toOid( Name, Map) with a NULL dn
+     */
+    public void testLdapNameToOidEmpty() throws Exception
+    {
+        Name name = new LdapDN() ;
+        
+        Map oids = new HashMap();
+        
+        oids.put( "dc", new OidNormalizer( "0.9.2342.19200300.100.1.25", new  DeepTrimToLowerNormalizer() ) );
+        oids.put( "ou", new OidNormalizer( "2.5.4.11", new  DeepTrimToLowerNormalizer() ) );
+        
+        Name result = LdapDN.toOidName( name, oids );
+        assertTrue( result.toString().equals( "" ) ) ;
+    }
+    
+    /**
+     * Class to test for toOid( Name, Map) with a multiple NameComponent
+     */
+    public void testLdapNameToOidMultiNC() throws Exception
+    {
+        Name name = new LdapDN( "ou= Some   People   + dc=  And   Some anImAls,dc = eXample,dc= cOm" ) ;
+        
+        Map oids = new HashMap();
+        
+        oids.put( "dc", new OidNormalizer( "0.9.2342.19200300.100.1.25", new  DeepTrimToLowerNormalizer() ) );
+        oids.put( "ou", new OidNormalizer( "2.5.4.11", new  DeepTrimToLowerNormalizer() ) );
+        
+        Name result = LdapDN.toOidName( name, oids );
+        
+        assertTrue( result.toString().equals( 
+            "0.9.2342.19200300.100.1.25=and some animals+2.5.4.11=some people,0.9.2342.19200300.100.1.25=example,0.9.2342.19200300.100.1.25=com" ) ) ;
+        assertTrue( ( (LdapDN)result).toUpName().equals( "ou= Some   People   + dc=  And   Some anImAls,dc = eXample,dc= cOm" ) );
+    }
+    
+    /**
+     * Test the serialization of a DN
+     * @throws Exception
+     */
+    public void testNameSerialization() throws Exception
+    {
+        Name name = new LdapDN( "ou= Some   People   + dc=  And   Some anImAls,dc = eXample,dc= cOm" ) ;
+
+        FileOutputStream fOut = null;
+    	ObjectOutputStream oOut = null;
+    	File file = new File( "LdapDN.ser" );
+
+    	try
+    	{
+    		fOut= new FileOutputStream( file);
+    		oOut = new ObjectOutputStream( fOut );
+    		oOut.writeObject( name );
+    	}
+    	catch ( IOException ioe )
+    	{
+    		throw ioe;
+    	}
+    	finally{
+	    	try {
+	    		oOut.flush();
+	    		oOut.close();
+	    		fOut.close();
+	    	} 
+	    	catch ( IOException ioe ) 
+	    	{
+	    		throw ioe;
+	    	}
+    	}
+
+    	FileInputStream fIn = null;
+    	ObjectInputStream oIn = null;
+
+    	try
+    	{
+    		fIn= new FileInputStream( file );
+    		oIn = new ObjectInputStream( fIn );
+
+    		LdapDN nameSer = (LdapDN)oIn.readObject();
+    		
+    		Assert.assertEquals( 0, nameSer.compareTo( name ) );
+    	}
+    	catch ( IOException ioe )
+    	{
+    		throw ioe;
+    	}
+    	finally
+    	{
+    		try 
+    		{
+    			oIn.close();
+    			fIn.close();
+    			file.delete();
+    		} 
+    		catch ( IOException ioe) 
+    		{
+    			throw ioe;
+    		}
+    	}
+    }
+}

Propchange: directory/branches/DN-refactoring/ldap-common/src/test/java/org/apache/ldap/common/name/LdapDNTest.java
------------------------------------------------------------------------------
    svn:executable = *

Added: directory/branches/DN-refactoring/ldap-common/src/test/java/org/apache/ldap/common/name/RdnTest.java
URL: http://svn.apache.org/viewcvs/directory/branches/DN-refactoring/ldap-common/src/test/java/org/apache/ldap/common/name/RdnTest.java?rev=366127&view=auto
==============================================================================
--- directory/branches/DN-refactoring/ldap-common/src/test/java/org/apache/ldap/common/name/RdnTest.java (added)
+++ directory/branches/DN-refactoring/ldap-common/src/test/java/org/apache/ldap/common/name/RdnTest.java Thu Jan  5 01:02:51 2006
@@ -0,0 +1,451 @@
+/*
+ *   Copyright 2005 The Apache Software Foundation
+ *
+ *   Licensed 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.ldap.common.name;
+
+import javax.naming.InvalidNameException;
+import javax.naming.NamingException;
+import javax.naming.directory.Attribute;
+import javax.naming.directory.Attributes;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.apache.ldap.common.name.Rdn;
+import org.apache.ldap.common.name.RdnParser;
+import org.apache.ldap.common.util.StringTools;
+
+/**
+ * Test the class Rdn
+ * 
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ */
+public class RdnTest extends TestCase
+{
+    //~ Methods ------------------------------------------------------------------------------------
+
+    /**
+     * Setup the test
+     */
+    protected void setUp()
+    {
+    }
+
+    /**
+     * Test a null RDN
+     */
+    public void testRdnNull() throws InvalidNameException
+    {
+        Assert.assertEquals( "", new Rdn().toString() );
+    }
+
+    /**
+     * test an empty RDN
+     */
+    public void testRdnEmpty() throws InvalidNameException
+    {
+        Assert.assertEquals( "", new Rdn( "" ).toString() );
+    }
+
+    /**
+     * test a simple RDN : a = b
+     */
+    public void testRdnSimple() throws InvalidNameException
+    {
+        Assert.assertEquals( "a=b", new Rdn( "a = b" ).toString() );
+    }
+
+    /**
+     * test a composite RDN : a = b, d = e
+     */
+    public void testRdnComposite() throws InvalidNameException
+    {
+        Assert.assertEquals( "a=b+c=d", new Rdn( "a = b + c = d" ).toString() );
+    }
+
+    /**
+     * test a composite RDN with or without spaces: a=b, a =b, a= b, a = b, a  =  b
+     */
+    public void testRdnCompositeWithSpace() throws InvalidNameException
+    {
+        Assert.assertEquals( "a=b", new Rdn( "a=b" ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( " a=b" ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( "a =b" ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( "a= b" ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( "a=b " ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( " a =b" ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( " a= b" ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( " a=b " ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( "a = b" ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( "a =b " ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( "a= b " ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( " a = b" ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( " a =b " ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( " a= b " ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( "a = b " ).toString() );
+        Assert.assertEquals( "a=b", new Rdn( " a = b " ).toString() );
+    }
+
+    /**
+     * test a simple RDN with differents separators : a = b + c = d
+     */
+    public void testRdnSimpleMultivaluedAttribute() throws InvalidNameException
+    {
+        String result = new Rdn( "a = b + c = d" ).toString(); 
+        Assert.assertEquals( "a=b+c=d", result );
+    }
+
+    /**
+     * test a composite RDN with differents separators : a=b+c=d, e=f + g=h + i=j
+     */
+    public void testRdnCompositeMultivaluedAttribute() throws InvalidNameException
+    {
+        Rdn rdn = new Rdn( "a =b+c=d + e=f + g  =h + i =j " );
+        
+        // NameComponent are not ordered
+        Assert.assertEquals( "b", rdn.getValue("a") );
+        Assert.assertEquals( "d", rdn.getValue("c") );
+        Assert.assertEquals( "f", rdn.getValue("  E  ") );
+        Assert.assertEquals( "h", rdn.getValue("g") );
+        Assert.assertEquals( "j", rdn.getValue("i") );
+    }
+
+    /**
+     * test a simple RDN with an oid prefix (uppercase) : OID.12.34.56 = azerty
+     */
+    public void testRdnOidUpper() throws InvalidNameException
+    {
+        Assert.assertEquals( "oid.12.34.56=azerty",
+                new Rdn( "OID.12.34.56 =  azerty" ).toString() );
+    }
+
+    /**
+     * test a simple RDN with an oid prefix (lowercase) : oid.12.34.56 = azerty
+     */
+    public void testRdnOidLower() throws InvalidNameException
+    {
+        Assert.assertEquals( "oid.12.34.56=azerty",
+                new Rdn( "oid.12.34.56 = azerty" ).toString() );
+    }
+
+    /**
+     * test a simple RDN with an oid attribut wiithout oid prefix : 12.34.56 = azerty
+     */
+    public void testRdnOidWithoutPrefix() throws InvalidNameException
+    {
+        Assert.assertEquals( "12.34.56=azerty",
+                new Rdn( "12.34.56 = azerty" ).toString() );
+    }
+
+    /**
+     * test a composite RDN with an oid attribut wiithout oid prefix : 12.34.56 = azerty; 7.8 = test
+     */
+    public void testRdnCompositeOidWithoutPrefix() throws InvalidNameException
+    {
+        String result = new Rdn( "12.34.56 = azerty + 7.8 = test" ).toString(); 
+        Assert.assertEquals( "12.34.56=azerty+7.8=test", result );
+    }
+
+    /**
+     * test a simple RDN with pair char attribute value : a = \,\=\+\<\>\#\;\\\"\A0\00"
+     */
+    public void testRdnPairCharAttributeValue() throws InvalidNameException
+    {
+        Assert.assertEquals( "a=\\,\\=\\+\\<\\>\\#\\;\\\\\\\"\\A0\\00",
+                new Rdn( "a = \\,\\=\\+\\<\\>\\#\\;\\\\\\\"\\A0\\00" ).toString() );
+    }
+
+    /**
+     * test a simple RDN with hexString attribute value : a = #0010A0AAFF
+     */
+    public void testRdnHexStringAttributeValue() throws InvalidNameException
+    {
+        Assert.assertEquals( "a=#0010A0AAFF",
+                new Rdn( "a = #0010A0AAFF" ).toString() );
+    }
+
+    /**
+     * test a simple RDN with quoted attribute value : a = "quoted \"value"
+     */
+    public void testRdnQuotedAttributeValue() throws InvalidNameException
+    {
+        Assert.assertEquals( "a=quoted \\\"value",
+                new Rdn( "a = quoted \\\"value" ).toString() );
+    }
+    
+    /**
+     * Test the clone method for a RDN.
+     */
+    public void testRDNCloningOneNameComponent()  throws InvalidNameException
+    {
+        Rdn rdn = new Rdn( "a", "b" );
+        
+        Rdn rdnClone = (Rdn)rdn.clone();
+        
+        RdnParser.parse( "c=d", rdn );
+        
+        Assert.assertEquals( "b" , rdnClone.getValue( "a" ) );
+    }
+
+    /**
+     * Test the clone method for a RDN.
+     */
+    public void testRDNCloningTwoNameComponent()  throws InvalidNameException
+    {
+        Rdn rdn = new Rdn( "a = b + aa = bb" );
+        
+        Rdn rdnClone = (Rdn)rdn.clone();
+        
+        rdn.clear();
+        RdnParser.parse( "c=d", rdn );
+        
+        Assert.assertEquals( "b" , rdnClone.getValue( "a" ) );
+        Assert.assertEquals( "bb" , rdnClone.getValue( "aa" ) );
+        Assert.assertEquals( "" , rdnClone.getValue( "c" ) );
+    }
+    
+    /**
+     * Test the compareTo method for a RDN.
+     */
+    public void testRDNCompareToNull() throws InvalidNameException
+    {
+        Rdn rdn1 = new Rdn( " a = b + c = d + a = f + g = h " );
+        Rdn rdn2 = null;
+        Assert.assertEquals( 1, rdn1.compareTo( rdn2 ) );
+    }
+
+    /**
+     * Compares a composite NC to a single NC.
+     */
+    public void testRDNCompareToNCS2NC() throws InvalidNameException
+    {
+        Rdn rdn1 = new Rdn( " a = b + c = d + a = f + g = h " );
+        Rdn rdn2 = new Rdn( " a = b " );
+        Assert.assertTrue( rdn1.compareTo( rdn2 ) > 0);
+    }
+
+    /**
+     * Compares a single NC to a composite NC.
+     */
+    public void testRDNCompareToNC2NCS() throws InvalidNameException
+    {
+        Rdn rdn1 = new Rdn( " a = b " );
+        Rdn rdn2 = new Rdn( " a = b + c = d + a = f + g = h " );
+
+        Assert.assertTrue( rdn1.compareTo( rdn2 ) < 0 );
+    }
+
+    /**
+     * Compares a composite NCS to a composite NCS in the same order.
+     */
+    public void testRDNCompareToNCS2NCSOrdered() throws InvalidNameException
+    {
+        Rdn rdn1 = new Rdn( " a = b + c = d + a = f + g = h " );
+        Rdn rdn2 = new Rdn( " a = b + c = d + a = f + g = h " );
+
+        Assert.assertEquals( 0, rdn1.compareTo( rdn2 ) );
+    }
+
+    /**
+     * Compares a composite NCS to a composite NCS in a different order.
+     */
+    public void testRDNCompareToNCS2NCSUnordered() throws InvalidNameException
+    {
+        Rdn rdn1 = new Rdn( " a = b + a = f + g = h + c = d " );
+        Rdn rdn2 = new Rdn( " a = b + c = d + a = f + g = h " );
+
+        Assert.assertEquals( 0, rdn1.compareTo( rdn2 ) );
+    }
+
+    /**
+     * Compares a composite NCS to a different composite NCS.
+     */
+    public void testRDNCompareToNCS2NCSNotEquals() throws InvalidNameException
+    {
+        Rdn rdn1 = new Rdn( " a = f + g = h + c = d " );
+        Rdn rdn2 = new Rdn( " c = d + a = h + g = h " );
+
+        Assert.assertEquals( -1, rdn1.compareTo( rdn2 ) );
+    }
+
+    /**
+     * Compares a simple NC to a simple NC.
+     */
+    public void testRDNCompareToNC2NC() throws InvalidNameException
+    {
+        Rdn rdn1 = new Rdn( " a = b " );
+        Rdn rdn2 = new Rdn( " a = b " );
+
+        Assert.assertEquals( 0, rdn1.compareTo( rdn2 ) );
+    }
+
+    /**
+     * Compares a simple NC to a simple NC in UperCase.
+     */
+    public void testRDNCompareToNC2NCUperCase() throws InvalidNameException
+    {
+        Rdn rdn1 = new Rdn( " a = b " );
+        Rdn rdn2 = new Rdn( " A = b " );
+
+        Assert.assertEquals( 0, rdn1.compareTo( rdn2 ) );
+        Assert.assertEquals( true, rdn1.equals( rdn2 ) );
+    }
+
+    /**
+     * Compares a simple NC to a different simple NC.
+     */
+    public void testRDNCompareToNC2NCNotEquals() throws InvalidNameException
+    {
+        Rdn rdn1 = new Rdn( " a = b " );
+        Rdn rdn2 = new Rdn( " A = d " );
+
+        Assert.assertTrue( rdn1.compareTo( rdn2 ) < 0 );
+    }
+    
+    public void testToAttributes() throws InvalidNameException, NamingException
+    {
+    	Rdn rdn = new Rdn( " a = b + a = f + g = h + c = d " );
+    	
+    	Attributes attributes = rdn.toAttributes();
+    	
+    	Assert.assertNotNull( attributes.get( "a" ) );
+    	Assert.assertNotNull( attributes.get( "g" ) );
+    	Assert.assertNotNull( attributes.get( "c" ) );
+    	
+    	Attribute attribute = attributes.get( "a" );
+    	
+    	Assert.assertNotNull( attribute.get( 0 ) );
+    	Assert.assertEquals( "b", attribute.get( 0 ) );
+    	
+    	Assert.assertNotNull( attribute.get( 1 ) );
+    	Assert.assertEquals( "f", attribute.get( 1 ) );
+
+    	attribute = attributes.get( "g" );
+    	Assert.assertNotNull( attribute.get( 0 ) );
+    	Assert.assertEquals( "h", attribute.get( 0 ) );
+
+    	attribute = attributes.get( "c" );
+    	Assert.assertNotNull( attribute.get( 0 ) );
+    	Assert.assertEquals( "d", attribute.get( 0 ) );
+    }
+    
+    public void testGetValue() throws InvalidNameException
+    {
+    	Rdn rdn = new Rdn( " a = b + a = f + g = h + c = d " );
+    	
+    	Assert.assertEquals( "b", rdn.getValue() );
+    }
+
+    public void testGetType() throws InvalidNameException
+    {
+    	Rdn rdn = new Rdn( " a = b + a = f + g = h + c = d " );
+    	
+    	Assert.assertEquals( "a", rdn.getType() );
+    }
+
+    public void testGetSize() throws InvalidNameException
+    {
+    	Rdn rdn = new Rdn( " a = b + a = f + g = h + c = d " );
+    	
+    	Assert.assertEquals( 4, rdn.size() );
+    }
+
+    public void testGetSize0() throws InvalidNameException
+    {
+    	Rdn rdn = new Rdn();
+    	
+    	Assert.assertEquals( 0, rdn.size() );
+    }
+    
+    public void testEquals() throws InvalidNameException
+    {
+    	Rdn rdn = new Rdn( "a=b + c=d + a=f" );
+    	
+    	Assert.assertFalse( rdn.equals( null ) );
+    	Assert.assertFalse( rdn.equals( new String( "test" ) ) );
+    	Assert.assertFalse( rdn.equals( new Rdn( "a=c + c=d + a=f" ) ) );
+    	Assert.assertFalse( rdn.equals( new Rdn( "a=b" ) ) );
+    	Assert.assertTrue( rdn.equals( new Rdn( "a=b + c=d + a=f" ) ) );
+    	Assert.assertTrue( rdn.equals( new Rdn( "a=b + C=d + A=f" ) ) );
+    	Assert.assertTrue( rdn.equals( new Rdn( "c=d + a=f + a=b" ) ) );
+    }
+
+    public void testUnescapeValueHexa() throws InvalidNameException
+    {
+    	byte[] res = (byte[])Rdn.unescapeValue( "#fF" );
+    	
+    	Assert.assertEquals( "0xFF ", StringTools.dumpBytes( res ) );
+    	
+    	res = (byte[])Rdn.unescapeValue( "#0123456789aBCDEF" );
+    	Assert.assertEquals( "0x01 0x23 0x45 0x67 0x89 0xAB 0xCD 0xEF ", StringTools.dumpBytes( res ) );
+    }
+
+    public void testUnescapeValueHexaWrong() throws InvalidNameException
+    {
+    	try
+    	{
+    		Rdn.unescapeValue( "#fF1" );
+    		Assert.fail(); // Should not happen
+    	}
+    	catch ( IllegalArgumentException iae )
+    	{
+    		Assert.assertTrue( true );
+    	}
+    }
+
+    public void testUnescapeValueString() throws InvalidNameException
+    {
+    	String res = (String)Rdn.unescapeValue( "azerty" );
+    	
+    	Assert.assertEquals( "azerty", res );
+    }
+
+    public void testUnescapeValueStringSpecial() throws InvalidNameException
+    {
+    	String res = (String)Rdn.unescapeValue( "\\\\\\#\\,\\+\\;\\<\\>\\=\\\"\\ " );
+    	
+    	Assert.assertEquals( "\\#,+;<>=\" ", res );
+    }
+
+    public void testEscapeValueString() throws InvalidNameException
+    {
+    	String res = Rdn.escapeValue( StringTools.getBytesUtf8( "azerty" ) );
+    	
+    	Assert.assertEquals( "azerty", res );
+    }
+
+    public void testEscapeValueStringSpecial() throws InvalidNameException
+    {
+    	String res = Rdn.escapeValue( StringTools.getBytesUtf8( "\\#,+;<>=\" " ) );
+    	
+    	Assert.assertEquals( "\\\\\\#\\,\\+\\;\\<\\>\\=\\\"\\ ", res );
+    }
+
+    public void testEscapeValueNumeric() throws InvalidNameException
+    {
+    	String res = Rdn.escapeValue( new byte[]{ '-', 0x00, '-', 0x1F, '-', 0x7F, '-' } );
+    	
+    	Assert.assertEquals( "-\\00-\\1F-\\7F-", res );
+    }
+
+    public void testEscapeValueMix() throws InvalidNameException
+    {
+    	String res = Rdn.escapeValue( new byte[]{ '\\', 0x00, '-', '+', '#', 0x7F, '-' } );
+    	
+    	Assert.assertEquals( "\\\\\\00-\\+\\#\\7F-", res );
+    }
+
+}

Propchange: directory/branches/DN-refactoring/ldap-common/src/test/java/org/apache/ldap/common/name/RdnTest.java
------------------------------------------------------------------------------
    svn:executable = *



Mime
View raw message