ldap/src/test/java/org/apache/directory/shared/ldap/name/RdnTest.java - directory-ldap-api - Git at Google

 /*
  *  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.shared.ldap.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.directory.shared.ldap.name.Rdn;
 import org.apache.directory.shared.ldap.name.RdnParser;
 import org.apache.directory.shared.ldap.util.StringTools;


 /**
  * Test the class Rdn
  *
  * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
  */
 public class RdnTest extends TestCase
 {
    // ~ Methods
    // ------------------------------------------------------------------------------------
    /**
     * Test a null RDN
     */
    public void testRdnNull()
    {
        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 = \,\=\+\<\>\#\;\\\"\C3\A9"
     */
    public void testRdnPairCharAttributeValue() throws InvalidNameException
    {
        String rdn = StringTools.utf8ToString( new byte[]{'a', '=', '\\', ',', '=', '\\', '+', '\\', '<',
            '\\', '>', '#', '\\', ';', '\\', '\\', '\\', '"', '\\', 'C', '3', '\\', 'A', '9' });
        Assert.assertEquals( rdn, new Rdn(
            "a = \\,=\\+\\<\\>#\\;\\\\\\\"\\C3\\A9" ).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 with a null RDN.
     */
    public void testRDNCompareToNullRdn() throws InvalidNameException
    {
        Rdn rdn1 = new Rdn( " a = b " );

        Assert.assertEquals( 1, rdn1.compareTo( null ) );
    }

    /**
     * Compares with a bad object
     */
    public void testRDNCompareToBadObject() throws InvalidNameException
    {
        Rdn rdn1 = new Rdn( " a = b " );

        Assert.assertEquals( Rdn.UNDEFINED, rdn1.compareTo( "test" ) );
    }

    /**
     * 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.getNormType() );
    }


    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()
    {
        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( "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()
    {
        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()
    {
        try
        {
            Rdn.unescapeValue( "#fF1" );
            Assert.fail(); // Should not happen
        }
        catch ( IllegalArgumentException iae )
        {
            Assert.assertTrue( true );
        }
    }


    public void testUnescapeValueString()
    {
        String res = ( String ) Rdn.unescapeValue( "azerty" );

        Assert.assertEquals( "azerty", res );
    }


    public void testUnescapeValueStringSpecial()
    {
        String res = ( String ) Rdn.unescapeValue( "\\\\\\#\\,\\+\\;\\<\\>\\=\\\"\\ " );

        Assert.assertEquals( "\\#,+;<>=\" ", res );
    }


    public void testEscapeValueString()
    {
        String res = Rdn.escapeValue( StringTools.getBytesUtf8( "azerty" ) );

        Assert.assertEquals( "azerty", res );
    }


    public void testEscapeValueStringSpecial()
    {
        String res = Rdn.escapeValue( StringTools.getBytesUtf8( "\\#,+;<>=\" " ) );

        Assert.assertEquals( "\\\\\\#\\,\\+\\;\\<\\>\\=\\\"\\ ", res );
    }


    public void testEscapeValueNumeric()
    {
        String res = Rdn.escapeValue( new byte[]
            { '-', 0x00, '-', 0x1F, '-', 0x7F, '-' } );

        Assert.assertEquals( "-\\00-\\1F-\\7F-", res );
    }


    public void testEscapeValueMix()
    {
        String res = Rdn.escapeValue( new byte[]
            { '\\', 0x00, '-', '+', '#', 0x7F, '-' } );

        Assert.assertEquals( "\\\\\\00-\\+\\#\\7F-", res );
    }

     public void testDIRSERVER_703() throws InvalidNameException
     {
         Rdn rdn = new Rdn( "cn=Kate Bush+sn=Bush" );
         assertEquals( "cn=Kate Bush+sn=Bush", rdn.getUpName() );
     }
 }
	/*
	* 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.shared.ldap.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.directory.shared.ldap.name.Rdn;
	import org.apache.directory.shared.ldap.name.RdnParser;
	import org.apache.directory.shared.ldap.util.StringTools;


	/**
	* Test the class Rdn
	*
	* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
	*/
	public class RdnTest extends TestCase
	{
	// ~ Methods
	// ------------------------------------------------------------------------------------
	/**
	* Test a null RDN
	*/
	public void testRdnNull()
	{
	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 = \,\=\+\<\>\#\;\\\"\C3\A9"
	*/
	public void testRdnPairCharAttributeValue() throws InvalidNameException
	{
	String rdn = StringTools.utf8ToString( new byte[]{'a', '=', '\\', ',', '=', '\\', '+', '\\', '<',
	'\\', '>', '#', '\\', ';', '\\', '\\', '\\', '"', '\\', 'C', '3', '\\', 'A', '9' });
	Assert.assertEquals( rdn, new Rdn(
	"a = \\,=\\+\\<\\>#\\;\\\\\\\"\\C3\\A9" ).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 with a null RDN.
	*/
	public void testRDNCompareToNullRdn() throws InvalidNameException
	{
	Rdn rdn1 = new Rdn( " a = b " );

	Assert.assertEquals( 1, rdn1.compareTo( null ) );
	}

	/**
	* Compares with a bad object
	*/
	public void testRDNCompareToBadObject() throws InvalidNameException
	{
	Rdn rdn1 = new Rdn( " a = b " );

	Assert.assertEquals( Rdn.UNDEFINED, rdn1.compareTo( "test" ) );
	}

	/**
	* 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.getNormType() );
	}


	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()
	{
	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( "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()
	{
	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()
	{
	try
	{
	Rdn.unescapeValue( "#fF1" );
	Assert.fail(); // Should not happen
	}
	catch ( IllegalArgumentException iae )
	{
	Assert.assertTrue( true );
	}
	}


	public void testUnescapeValueString()
	{
	String res = ( String ) Rdn.unescapeValue( "azerty" );

	Assert.assertEquals( "azerty", res );
	}


	public void testUnescapeValueStringSpecial()
	{
	String res = ( String ) Rdn.unescapeValue( "\\\\\\#\\,\\+\\;\\<\\>\\=\\\"\\ " );

	Assert.assertEquals( "\\#,+;<>=\" ", res );
	}


	public void testEscapeValueString()
	{
	String res = Rdn.escapeValue( StringTools.getBytesUtf8( "azerty" ) );

	Assert.assertEquals( "azerty", res );
	}


	public void testEscapeValueStringSpecial()
	{
	String res = Rdn.escapeValue( StringTools.getBytesUtf8( "\\#,+;<>=\" " ) );

	Assert.assertEquals( "\\\\\\#\\,\\+\\;\\<\\>\\=\\\"\\ ", res );
	}


	public void testEscapeValueNumeric()
	{
	String res = Rdn.escapeValue( new byte[]
	{ '-', 0x00, '-', 0x1F, '-', 0x7F, '-' } );

	Assert.assertEquals( "-\\00-\\1F-\\7F-", res );
	}


	public void testEscapeValueMix()
	{
	String res = Rdn.escapeValue( new byte[]
	{ '\\', 0x00, '-', '+', '#', 0x7F, '-' } );

	Assert.assertEquals( "\\\\\\00-\\+\\#\\7F-", res );
	}

	public void testDIRSERVER_703() throws InvalidNameException
	{
	Rdn rdn = new Rdn( "cn=Kate Bush+sn=Bush" );
	assertEquals( "cn=Kate Bush+sn=Bush", rdn.getUpName() );
	}
	}