Return-Path: X-Original-To: apmail-directory-commits-archive@www.apache.org Delivered-To: apmail-directory-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 1385AD2DD for ; Wed, 19 Dec 2012 17:26:11 +0000 (UTC) Received: (qmail 63781 invoked by uid 500); 19 Dec 2012 17:26:11 -0000 Delivered-To: apmail-directory-commits-archive@directory.apache.org Received: (qmail 63651 invoked by uid 500); 19 Dec 2012 17:26:10 -0000 Mailing-List: contact commits-help@directory.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@directory.apache.org Delivered-To: mailing list commits@directory.apache.org Received: (qmail 63638 invoked by uid 99); 19 Dec 2012 17:26:10 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 19 Dec 2012 17:26:10 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 19 Dec 2012 17:26:06 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id BF6B723889E0; Wed, 19 Dec 2012 17:25:46 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1423968 [4/27] - in /directory/shared/branches/shared-refact: dsml/engine/src/main/java/org/apache/directory/shared/dsmlv2/engine/ dsml/parser/src/main/java/org/apache/directory/shared/dsmlv2/ dsml/parser/src/main/java/org/apache/directory... Date: Wed, 19 Dec 2012 17:24:42 -0000 To: commits@directory.apache.org From: elecharny@apache.org X-Mailer: svnmailer-1.0.8-patched Message-Id: <20121219172546.BF6B723889E0@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Added: directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareAttributeSerializationTest.java URL: http://svn.apache.org/viewvc/directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareAttributeSerializationTest.java?rev=1423968&view=auto ============================================================================== --- directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareAttributeSerializationTest.java (added) +++ directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareAttributeSerializationTest.java Wed Dec 19 17:24:08 2012 @@ -0,0 +1,218 @@ +/* + * 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.api.ldap.entry; + + +import static org.junit.Assert.assertEquals; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; + +import org.apache.directory.api.ldap.model.entry.Attribute; +import org.apache.directory.api.ldap.model.entry.DefaultAttribute; +import org.apache.directory.api.ldap.model.exception.LdapInvalidAttributeValueException; +import org.apache.directory.api.ldap.model.schema.AttributeType; +import org.apache.directory.api.ldap.model.schema.SchemaManager; +import org.apache.directory.shared.ldap.schemamanager.impl.DefaultSchemaManager; +import org.junit.BeforeClass; +import org.junit.Test; + + +/** + * Test the Attribute Serialization + * + * @author Apache Directory Project + */ +public class SchemaAwareAttributeSerializationTest +{ + private static byte[] data1 = new byte[] + { 0x01, 0x02, 0x03, 0x04 }; + private static byte[] data2 = new byte[] + { 0x05, 0x06, 0x07, 0x08 }; + private static byte[] data3 = new byte[] + { 0x09, 0x0A, 0x0B, 0x0C }; + + private static AttributeType cn = null; + private static AttributeType userCertificate = null; + + private static SchemaManager schemaManager; + + + /** + * Initialize OIDs maps for normalization + */ + @BeforeClass + public static void setup() throws Exception + { + schemaManager = new DefaultSchemaManager(); + cn = schemaManager.getAttributeType( "cn" ); + userCertificate = schemaManager.getAttributeType( "userCertificate" ); + } + + + @Test + public void testEntryAttributeNoStringValueSerialization() throws IOException, ClassNotFoundException, + LdapInvalidAttributeValueException + { + Attribute attribute1 = new DefaultAttribute( cn ); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream( baos ); + + attribute1.writeExternal( out ); + + ObjectInputStream in = null; + + byte[] data = baos.toByteArray(); + in = new ObjectInputStream( new ByteArrayInputStream( data ) ); + + Attribute attribute2 = new DefaultAttribute( cn ); + attribute2.readExternal( in ); + attribute2.apply( cn ); + + assertEquals( attribute1, attribute2 ); + } + + + @Test + public void testEntryAttributeOneStringValueSerialization() throws IOException, ClassNotFoundException, + LdapInvalidAttributeValueException + { + Attribute attribute1 = new DefaultAttribute( "CommonName", cn, "test" ); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream( baos ); + + attribute1.writeExternal( out ); + + ObjectInputStream in = null; + + byte[] data = baos.toByteArray(); + in = new ObjectInputStream( new ByteArrayInputStream( data ) ); + + Attribute attribute2 = new DefaultAttribute( cn ); + attribute2.readExternal( in ); + attribute2.apply( cn ); + + assertEquals( attribute1, attribute2 ); + assertEquals( "CommonName", attribute2.getUpId() ); + } + + + @Test + public void testEntryAttributeManyStringValuesSerialization() throws IOException, ClassNotFoundException, + LdapInvalidAttributeValueException + { + Attribute attribute1 = new DefaultAttribute( "CN", cn, "test1", "test2", "test3" ); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream( baos ); + + attribute1.writeExternal( out ); + + ObjectInputStream in = null; + + byte[] data = baos.toByteArray(); + in = new ObjectInputStream( new ByteArrayInputStream( data ) ); + + Attribute attribute2 = new DefaultAttribute( cn ); + attribute2.readExternal( in ); + attribute2.apply( cn ); + + assertEquals( attribute1, attribute2 ); + assertEquals( "CN", attribute2.getUpId() ); + } + + + @Test + public void testEntryAttributeNoBinaryValueSerialization() throws IOException, ClassNotFoundException, + LdapInvalidAttributeValueException, LdapInvalidAttributeValueException + { + Attribute attribute1 = new DefaultAttribute( userCertificate ); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream( baos ); + + attribute1.writeExternal( out ); + + ObjectInputStream in = null; + + byte[] data = baos.toByteArray(); + in = new ObjectInputStream( new ByteArrayInputStream( data ) ); + + Attribute attribute2 = new DefaultAttribute( userCertificate ); + attribute2.readExternal( in ); + attribute2.apply( userCertificate ); + + assertEquals( attribute1, attribute2 ); + } + + + @Test + public void testEntryAttributeOneBinaryValueSerialization() throws IOException, ClassNotFoundException, + LdapInvalidAttributeValueException + { + Attribute attribute1 = new DefaultAttribute( userCertificate, data1 ); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream( baos ); + + attribute1.writeExternal( out ); + + ObjectInputStream in = null; + + byte[] data = baos.toByteArray(); + in = new ObjectInputStream( new ByteArrayInputStream( data ) ); + + Attribute attribute2 = new DefaultAttribute( userCertificate ); + attribute2.readExternal( in ); + attribute2.apply( userCertificate ); + + assertEquals( attribute1, attribute2 ); + } + + + @Test + public void testEntryAttributeManyBinaryValuesSerialization() throws IOException, ClassNotFoundException, + LdapInvalidAttributeValueException + { + Attribute attribute1 = new DefaultAttribute( "UserCertificate", userCertificate, data1, data2, data3 ); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream( baos ); + + attribute1.writeExternal( out ); + + ObjectInputStream in = null; + + byte[] data = baos.toByteArray(); + in = new ObjectInputStream( new ByteArrayInputStream( data ) ); + + Attribute attribute2 = new DefaultAttribute( userCertificate ); + attribute2.readExternal( in ); + attribute2.apply( userCertificate ); + + assertEquals( attribute1, attribute2 ); + assertEquals( "UserCertificate", attribute2.getUpId() ); + } +} Propchange: directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareAttributeSerializationTest.java ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareAttributeTest.java URL: http://svn.apache.org/viewvc/directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareAttributeTest.java?rev=1423968&view=auto ============================================================================== --- directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareAttributeTest.java (added) +++ directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareAttributeTest.java Wed Dec 19 17:24:08 2012 @@ -0,0 +1,2135 @@ +/* + * 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.api.ldap.entry; + + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; + +import org.apache.directory.api.ldap.model.entry.Attribute; +import org.apache.directory.api.ldap.model.entry.BinaryValue; +import org.apache.directory.api.ldap.model.entry.DefaultAttribute; +import org.apache.directory.api.ldap.model.entry.StringValue; +import org.apache.directory.api.ldap.model.entry.Value; +import org.apache.directory.api.ldap.model.exception.LdapException; +import org.apache.directory.api.ldap.model.exception.LdapInvalidAttributeValueException; +import org.apache.directory.api.ldap.model.schema.AttributeType; +import org.apache.directory.api.ldap.model.schema.SchemaManager; +import org.apache.directory.api.util.StringConstants; +import org.apache.directory.api.util.Strings; +import org.apache.directory.shared.ldap.schemamanager.impl.DefaultSchemaManager; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.mycila.junit.concurrent.Concurrency; +import com.mycila.junit.concurrent.ConcurrentJunitRunner; + + +@RunWith(ConcurrentJunitRunner.class) +@Concurrency() +/** + * Test the schema aware Attribute + * + * @author Apache Directory Project + */ +public class SchemaAwareAttributeTest +{ + private AttributeType atCN = null; + private AttributeType atDC; + private AttributeType atSN; + private AttributeType atName; + + // A SINGLE-VALUE attribute + private AttributeType atC; + + // A Binary attribute + private AttributeType atPwd; + + // A String attribute which allows null value + private AttributeType atEMail; + + private final Value NULL_STRING_VALUE = new StringValue( ( String ) null ); + private final Value NULL_BINARY_VALUE = new BinaryValue( ( byte[] ) null ); + private final byte[] BYTES1 = new byte[] + { 'a', 'b' }; + private final byte[] BYTES2 = new byte[] + { 'b' }; + private final byte[] BYTES3 = new byte[] + { 'c' }; + private final byte[] BYTES4 = new byte[] + { 'd' }; + + private final StringValue STR_VALUE1 = new StringValue( "a" ); + private final StringValue STR_VALUE2 = new StringValue( "b" ); + private final StringValue STR_VALUE3 = new StringValue( "c" ); + private final StringValue STR_VALUE4 = new StringValue( "d" ); + + private final BinaryValue BIN_VALUE1 = new BinaryValue( BYTES1 ); + private final BinaryValue BIN_VALUE2 = new BinaryValue( BYTES2 ); + private final BinaryValue BIN_VALUE3 = new BinaryValue( BYTES3 ); + private final BinaryValue BIN_VALUE4 = new BinaryValue( BYTES4 ); + + private static SchemaManager schemaManager; + + + /** + * Serialize a DefaultEntryAttribute + */ + private ByteArrayOutputStream serializeValue( DefaultAttribute value ) throws IOException + { + ObjectOutputStream oOut = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + + try + { + oOut = new ObjectOutputStream( out ); + value.writeExternal( oOut ); + } + catch ( IOException ioe ) + { + throw ioe; + } + finally + { + try + { + if ( oOut != null ) + { + oOut.flush(); + oOut.close(); + } + } + catch ( IOException ioe ) + { + throw ioe; + } + } + + return out; + } + + + /** + * Deserialize a DefaultEntryAttribute + */ + private DefaultAttribute deserializeValue( ByteArrayOutputStream out, AttributeType at ) throws IOException, + ClassNotFoundException + { + ObjectInputStream oIn = null; + ByteArrayInputStream in = new ByteArrayInputStream( out.toByteArray() ); + + try + { + oIn = new ObjectInputStream( in ); + + DefaultAttribute value = new DefaultAttribute( at ); + value.readExternal( oIn ); + + return value; + } + catch ( IOException ioe ) + { + throw ioe; + } + finally + { + try + { + if ( oIn != null ) + { + oIn.close(); + } + } + catch ( IOException ioe ) + { + throw ioe; + } + } + } + + + @BeforeClass + public static void startup() throws Exception + { + schemaManager = new DefaultSchemaManager(); + } + + + /** + * Initialize the schemaManager + */ + @Before + public void setup() throws Exception + { + atCN = schemaManager.getAttributeType( "cn" ); + atDC = schemaManager.lookupAttributeTypeRegistry( "dc" ); + atC = schemaManager.lookupAttributeTypeRegistry( "c" ); + atSN = schemaManager.lookupAttributeTypeRegistry( "sn" ); + atPwd = schemaManager.lookupAttributeTypeRegistry( "userpassword" ); + atEMail = schemaManager.lookupAttributeTypeRegistry( "email" ); + atName = schemaManager.lookupAttributeTypeRegistry( "name" ); + } + + + /** + * Test method isValid( SyntaxChecker ) + */ + @Test + public void testIsValidSyntaxChecker() throws LdapException + { + Attribute attr = new DefaultAttribute( "test" ); + + attr.add( "test", "another test" ); + + assertTrue( attr.isValid( atCN ) ); + + attr.add( "test an invalid '\uFFFD' char" ); + assertFalse( attr.isValid( atCN ) ); + } + + + @Test + public void testAddOneValue() throws Exception + { + AttributeType at = TestEntryUtils.getIA5StringAttributeType(); + + DefaultAttribute attr = new DefaultAttribute( at ); + + // Add a String value + attr.add( "test" ); + + assertEquals( 1, attr.size() ); + + assertTrue( attr.getAttributeType().getSyntax().isHumanReadable() ); + + Value value = attr.get(); + + assertTrue( value instanceof StringValue ); + assertEquals( "test", ( ( StringValue ) value ).getString() ); + + // Add a binary value + assertEquals( 0, attr.add( new byte[] + { 0x01 } ) ); + + // Add a Value + Value ssv = new StringValue( at, "test2" ); + + attr.add( ssv ); + + assertEquals( 2, attr.size() ); + + Set expected = new HashSet(); + expected.add( "test" ); + expected.add( "test2" ); + + for ( Value val : attr ) + { + if ( expected.contains( val.getValue() ) ) + { + expected.remove( val.getValue() ); + } + else + { + fail(); + } + } + + assertEquals( 0, expected.size() ); + } + + + @Test + public void testAddTwoValue() throws Exception + { + AttributeType at = TestEntryUtils.getIA5StringAttributeType(); + + DefaultAttribute attr = new DefaultAttribute( at ); + + // Add String values + attr.add( "test" ); + attr.add( "test2" ); + + assertEquals( 2, attr.size() ); + + assertTrue( attr.getAttributeType().getSyntax().isHumanReadable() ); + + Set expected = new HashSet(); + expected.add( "test" ); + expected.add( "test2" ); + + for ( Value val : attr ) + { + if ( expected.contains( val.getValue() ) ) + { + expected.remove( val.getValue() ); + } + else + { + fail(); + } + } + + assertEquals( 0, expected.size() ); + } + + + @Test + public void testAddNullValue() throws Exception + { + AttributeType at = TestEntryUtils.getIA5StringAttributeType(); + + DefaultAttribute attr = new DefaultAttribute( at ); + + // Add a null value + attr.add( new StringValue( at, null ) ); + + assertEquals( 1, attr.size() ); + + assertTrue( attr.getAttributeType().getSyntax().isHumanReadable() ); + + Value value = attr.get(); + + assertTrue( value instanceof StringValue ); + assertNull( ( ( StringValue ) value ).getValue() ); + } + + + @Test + public void testGetAttribute() throws Exception + { + AttributeType at = TestEntryUtils.getIA5StringAttributeType(); + + DefaultAttribute attr = new DefaultAttribute( at ); + + attr.add( "Test1" ); + attr.add( "Test2" ); + attr.add( "Test3" ); + + assertEquals( "1.1", attr.getId() ); + assertEquals( 3, attr.size() ); + assertTrue( attr.contains( "Test1" ) ); + assertTrue( attr.contains( "Test2" ) ); + assertTrue( attr.contains( "Test3" ) ); + } + + + /** + * Test the contains() method + */ + @Test + public void testContains() throws Exception + { + AttributeType at = TestEntryUtils.getIA5StringAttributeType(); + + DefaultAttribute attr = new DefaultAttribute( at ); + + attr.add( "Test 1" ); + attr.add( "Test 2" ); + attr.add( "Test 3" ); + + assertTrue( attr.contains( "test 1" ) ); + assertTrue( attr.contains( "Test 2" ) ); + assertTrue( attr.contains( "TEST 3" ) ); + } + + + /** + * Test method getBytes() + */ + @Test + public void testGetBytes() throws LdapInvalidAttributeValueException + { + Attribute attr1 = new DefaultAttribute( atPwd ); + + attr1.add( ( byte[] ) null ); + assertNull( attr1.getBytes() ); + + Attribute attr2 = new DefaultAttribute( atPwd ); + + attr2.add( BYTES1, BYTES2 ); + assertTrue( Arrays.equals( BYTES1, attr2.getBytes() ) ); + + Attribute attr3 = new DefaultAttribute( atCN ); + + attr3.add( "a", "b" ); + + try + { + attr3.getBytes(); + fail(); + } + catch ( LdapInvalidAttributeValueException ivae ) + { + assertTrue( true ); + } + } + + + /** + * Test method getId() + */ + @Test + public void testGetId() + { + Attribute attr = new DefaultAttribute( atCN ); + + assertEquals( "2.5.4.3", attr.getId() ); + + attr.setUpId( " CN " ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( " CN ", attr.getUpId() ); + + attr.setUpId( " CommonName " ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( " CommonName ", attr.getUpId() ); + + attr.setUpId( " 2.5.4.3 " ); + assertEquals( "2.5.4.3", attr.getId() ); + } + + + /** + * Test method getString() + */ + @Test + public void testGetString() throws LdapInvalidAttributeValueException + { + Attribute attr1 = new DefaultAttribute( atDC ); + + assertEquals( 1, attr1.add( ( String ) null ) ); + + Attribute attr2 = new DefaultAttribute( atDC ); + + attr2.add( "a" ); + assertEquals( "a", attr2.getString() ); + + Attribute attr3 = new DefaultAttribute( atPwd ); + + attr3.add( BYTES1, BYTES2 ); + + try + { + attr3.getString(); + fail(); + } + catch ( LdapInvalidAttributeValueException ivae ) + { + assertTrue( true ); + } + } + + + /** + * Test method getUpId + */ + @Test + public void testGetUpId() + { + Attribute attr = new DefaultAttribute( atCN ); + + assertNotNull( attr.getUpId() ); + assertEquals( "cn", attr.getUpId() ); + + attr.setUpId( "CN" ); + assertEquals( "CN", attr.getUpId() ); + + attr.setUpId( " Cn " ); + assertEquals( " Cn ", attr.getUpId() ); + + attr.setUpId( " 2.5.4.3 " ); + assertEquals( " 2.5.4.3 ", attr.getUpId() ); + } + + + /** + * Test method hashCode() + */ + @Test + public void testHashCode() throws LdapException + { + Attribute attr1 = new DefaultAttribute( atDC ); + Attribute attr2 = new DefaultAttribute( atSN ); + assertNotSame( attr1.hashCode(), attr2.hashCode() ); + + attr2.apply( atDC ); + assertEquals( attr1.hashCode(), attr2.hashCode() ); + + attr1.add( ( String ) null ); + assertNotSame( attr1.hashCode(), attr2.hashCode() ); + + attr1.clear(); + assertEquals( attr1.hashCode(), attr2.hashCode() ); + + attr1.add( "a", "b" ); + assertNotSame( attr1.hashCode(), attr2.hashCode() ); + + attr2.add( "a", "b" ); + assertEquals( attr1.hashCode(), attr2.hashCode() ); + + // Order matters + attr2.clear(); + attr2.add( "b", "a" ); + assertNotSame( attr1.hashCode(), attr2.hashCode() ); + + Attribute attr3 = new DefaultAttribute( atPwd ); + Attribute attr4 = new DefaultAttribute( atPwd ); + assertNotSame( attr3.hashCode(), attr4.hashCode() ); + + attr3.add( ( byte[] ) null ); + assertNotSame( attr3.hashCode(), attr4.hashCode() ); + + attr3.clear(); + assertEquals( attr3.hashCode(), attr4.hashCode() ); + + attr3.add( new byte[] + { 0x01, 0x02 }, new byte[] + { 0x03, 0x04 } ); + assertNotSame( attr1.hashCode(), attr2.hashCode() ); + + attr4.add( new byte[] + { 0x01, 0x02 }, new byte[] + { 0x03, 0x04 } ); + assertNotSame( attr1.hashCode(), attr2.hashCode() ); + + // Order matters + attr4.clear(); + attr4.add( new byte[] + { 0x03, 0x04 }, new byte[] + { 0x01, 0x02 } ); + assertNotSame( attr1.hashCode(), attr2.hashCode() ); + } + + + /** + * Test method SetId(String) + */ + @Test + public void testSetId() + { + Attribute attr = new DefaultAttribute( atCN ); + + attr.setUpId( "Cn" ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "Cn", attr.getUpId() ); + + attr.setUpId( " CN " ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( " CN ", attr.getUpId() ); + + attr.setUpId( " 2.5.4.3 " ); + assertEquals( " 2.5.4.3 ", attr.getUpId() ); + assertEquals( "2.5.4.3", attr.getId() ); + + attr.setUpId( " commonName " ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( " commonName ", attr.getUpId() ); + + attr.setUpId( null ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "cn", attr.getUpId() ); + + attr.setUpId( "" ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "cn", attr.getUpId() ); + + attr.setUpId( " " ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "cn", attr.getUpId() ); + + try + { + attr.setUpId( " SN " ); + fail(); + } + catch ( IllegalArgumentException iae ) + { + assertTrue( true ); + } + } + + + /** + * Test method isValid() + */ + @Test + public void testIsValid() throws Exception + { + Attribute attr = new DefaultAttribute( atCN ); + + // No value, this should not be valid + assertFalse( attr.isValid( atCN ) ); + + attr.add( "test", "test2", "A123\\;" ); + assertTrue( attr.isValid( atCN ) ); + + // If we try to add a wrong value, it will not be added. The + // attribute remains valid. + assertEquals( 0, attr.add( new byte[] + { 0x01 } ) ); + assertTrue( attr.isValid( atCN ) ); + + // test a SINGLE-VALUE attribute. CountryName is SINGLE-VALUE + attr.clear(); + attr.apply( atC ); + attr.add( "FR" ); + assertTrue( attr.isValid( atC ) ); + assertEquals( 0, attr.add( "US" ) ); + assertFalse( attr.contains( "US" ) ); + assertTrue( attr.isValid( atC ) ); + } + + + /** + * Test method add( Value... ) + */ + @Test + public void testAddValueArray() throws LdapException + { + Attribute attr1 = new DefaultAttribute( atDC ); + + int nbAdded = attr1.add( ( String ) null ); + assertEquals( 1, nbAdded ); + assertTrue( attr1.isHumanReadable() ); + assertEquals( NULL_STRING_VALUE, attr1.get() ); + + Attribute attr2 = new DefaultAttribute( atPwd ); + + nbAdded = attr2.add( new BinaryValue( atPwd, null ) ); + assertEquals( 1, nbAdded ); + assertFalse( attr2.isHumanReadable() ); + assertEquals( NULL_BINARY_VALUE, attr2.get() ); + + Attribute attr3 = new DefaultAttribute( atCN ); + + nbAdded = attr3.add( new StringValue( atCN, "a" ), new StringValue( atCN, "b" ) ); + assertEquals( 2, nbAdded ); + assertTrue( attr3.isHumanReadable() ); + assertTrue( attr3.contains( "a" ) ); + assertTrue( attr3.contains( "b" ) ); + + Attribute attr4 = new DefaultAttribute( atCN ); + + nbAdded = attr4.add( new BinaryValue( atPwd, BYTES1 ), new BinaryValue( atPwd, BYTES2 ) ); + assertEquals( 0, nbAdded ); + assertTrue( attr4.isHumanReadable() ); + assertFalse( attr4.contains( BYTES1 ) ); + assertFalse( attr4.contains( BYTES2 ) ); + + Attribute attr5 = new DefaultAttribute( atCN ); + + nbAdded = attr5.add( new StringValue( atCN, "c" ), new BinaryValue( atPwd, BYTES1 ) ); + assertEquals( 1, nbAdded ); + assertTrue( attr5.isHumanReadable() ); + assertFalse( attr5.contains( "ab" ) ); + assertTrue( attr5.contains( "c" ) ); + + Attribute attr6 = new DefaultAttribute( atPwd ); + + nbAdded = attr6.add( new BinaryValue( atPwd, BYTES1 ), new StringValue( atCN, "c" ) ); + assertEquals( 1, nbAdded ); + assertFalse( attr6.isHumanReadable() ); + assertTrue( attr6.contains( BYTES1 ) ); + assertFalse( attr6.contains( BYTES3 ) ); + + Attribute attr7 = new DefaultAttribute( atPwd ); + + nbAdded = attr7.add( new BinaryValue( atPwd, null ), new StringValue( atCN, "c" ) ); + assertEquals( 1, nbAdded ); + assertFalse( attr7.isHumanReadable() ); + assertTrue( attr7.contains( NULL_BINARY_VALUE ) ); + assertFalse( attr7.contains( BYTES3 ) ); + + Attribute attr8 = new DefaultAttribute( atDC ); + + nbAdded = attr8.add( new StringValue( atDC, null ), new BinaryValue( atPwd, BYTES1 ) ); + assertEquals( 1, nbAdded ); + assertTrue( attr8.isHumanReadable() ); + assertTrue( attr8.contains( NULL_STRING_VALUE ) ); + assertFalse( attr8.contains( "ab" ) ); + + Attribute attr9 = new DefaultAttribute( atDC ); + + nbAdded = attr9.add( new StringValue( ( String ) null ), new StringValue( "ab" ) ); + assertEquals( 2, nbAdded ); + assertTrue( attr9.isHumanReadable() ); + assertTrue( attr9.contains( NULL_STRING_VALUE ) ); + assertTrue( attr9.contains( "ab" ) ); + + Attribute attr10 = new DefaultAttribute( atPwd ); + + nbAdded = attr10.add( new BinaryValue( ( byte[] ) null ), new BinaryValue( BYTES1 ) ); + assertEquals( 2, nbAdded ); + assertFalse( attr10.isHumanReadable() ); + assertTrue( attr10.contains( NULL_BINARY_VALUE ) ); + assertTrue( attr10.contains( BYTES1 ) ); + } + + + /** + * Test method add( String... ) + */ + @Test + public void testAddStringArray() throws LdapInvalidAttributeValueException + { + Attribute attr1 = new DefaultAttribute( atDC ); + + int nbAdded = attr1.add( ( String ) null ); + assertEquals( 1, nbAdded ); + assertTrue( attr1.isHumanReadable() ); + assertEquals( NULL_STRING_VALUE, attr1.get() ); + + Attribute attr2 = new DefaultAttribute( atDC ); + + nbAdded = attr2.add( "" ); + assertEquals( 1, nbAdded ); + assertTrue( attr2.isHumanReadable() ); + assertEquals( "", attr2.getString() ); + + Attribute attr3 = new DefaultAttribute( atCN ); + + nbAdded = attr3.add( "t" ); + assertEquals( 1, nbAdded ); + assertTrue( attr3.isHumanReadable() ); + assertEquals( "t", attr3.getString() ); + + Attribute attr4 = new DefaultAttribute( atCN ); + + nbAdded = attr4.add( "a", "b", "c", "d" ); + assertEquals( 4, nbAdded ); + assertTrue( attr4.isHumanReadable() ); + assertEquals( "a", attr4.getString() ); + assertTrue( attr4.contains( "a" ) ); + assertTrue( attr4.contains( "b" ) ); + assertTrue( attr4.contains( "c" ) ); + assertTrue( attr4.contains( "d" ) ); + + nbAdded = attr4.add( "e" ); + assertEquals( 1, nbAdded ); + assertTrue( attr4.isHumanReadable() ); + assertEquals( "a", attr4.getString() ); + assertTrue( attr4.contains( "a" ) ); + assertTrue( attr4.contains( "b" ) ); + assertTrue( attr4.contains( "c" ) ); + assertTrue( attr4.contains( "d" ) ); + assertTrue( attr4.contains( "e" ) ); + + nbAdded = attr4.add( BYTES1 ); + assertEquals( 0, nbAdded ); + assertTrue( attr4.isHumanReadable() ); + assertEquals( "a", attr4.getString() ); + assertTrue( attr4.contains( "a" ) ); + assertTrue( attr4.contains( "b" ) ); + assertTrue( attr4.contains( "c" ) ); + assertTrue( attr4.contains( "d" ) ); + assertTrue( attr4.contains( "e" ) ); + assertFalse( attr4.contains( "ab" ) ); + + Attribute attr5 = new DefaultAttribute( atEMail ); + + nbAdded = attr5.add( "a", "b", ( String ) null, "d" ); + assertEquals( 4, nbAdded ); + assertTrue( attr5.isHumanReadable() ); + assertTrue( attr5.contains( "a" ) ); + assertTrue( attr5.contains( "b" ) ); + assertTrue( attr5.contains( NULL_STRING_VALUE ) ); + assertTrue( attr5.contains( "d" ) ); + + Attribute attr6 = new DefaultAttribute( atPwd ); + + nbAdded = attr6.add( "a", ( String ) null ); + assertEquals( 2, nbAdded ); + assertFalse( attr6.isHumanReadable() ); + } + + + /** + * Test method add( byte[]... ) + */ + @Test + public void testAddByteArray() throws LdapInvalidAttributeValueException + { + Attribute attr1 = new DefaultAttribute( atPwd ); + + int nbAdded = attr1.add( ( byte[] ) null ); + assertEquals( 1, nbAdded ); + assertFalse( attr1.isHumanReadable() ); + assertTrue( Arrays.equals( NULL_BINARY_VALUE.getBytes(), attr1.getBytes() ) ); + + Attribute attr2 = new DefaultAttribute( atPwd ); + + nbAdded = attr2.add( StringConstants.EMPTY_BYTES ); + assertEquals( 1, nbAdded ); + assertFalse( attr2.isHumanReadable() ); + assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, attr2.getBytes() ) ); + + Attribute attr3 = new DefaultAttribute( atPwd ); + + nbAdded = attr3.add( BYTES1 ); + assertEquals( 1, nbAdded ); + assertFalse( attr3.isHumanReadable() ); + assertTrue( Arrays.equals( BYTES1, attr3.getBytes() ) ); + + Attribute attr4 = new DefaultAttribute( atPwd ); + + nbAdded = attr4.add( BYTES1, BYTES2, BYTES3, BYTES4 ); + assertEquals( 4, nbAdded ); + assertFalse( attr4.isHumanReadable() ); + assertTrue( attr4.contains( BYTES1 ) ); + assertTrue( attr4.contains( BYTES2 ) ); + assertTrue( attr4.contains( BYTES3 ) ); + assertTrue( attr4.contains( BYTES4 ) ); + + Attribute attr5 = new DefaultAttribute( atPwd ); + + nbAdded = attr5.add( BYTES1, BYTES2, ( byte[] ) null, BYTES3 ); + assertEquals( 4, nbAdded ); + assertFalse( attr5.isHumanReadable() ); + assertTrue( attr5.contains( BYTES1 ) ); + assertTrue( attr5.contains( BYTES2 ) ); + assertTrue( attr5.contains( ( byte[] ) null ) ); + assertTrue( attr5.contains( BYTES3 ) ); + + Attribute attr6 = new DefaultAttribute( atPwd ); + + nbAdded = attr6.add( "ab", ( String ) null ); + assertEquals( 2, nbAdded ); + assertFalse( attr6.isHumanReadable() ); + } + + + /** + * Test method clear() + */ + @Test + public void testClear() throws LdapException + { + Attribute attr = new DefaultAttribute( "email", atEMail ); + + assertEquals( 0, attr.size() ); + + attr.add( ( String ) null, "a", "b" ); + assertEquals( 3, attr.size() ); + + attr.clear(); + assertTrue( attr.isHumanReadable() ); + assertEquals( 0, attr.size() ); + assertEquals( atEMail, attr.getAttributeType() ); + } + + + /** + * Test method contains( Value... ) throws LdapException + */ + @Test + public void testContainsValueArray() throws LdapException + { + Attribute attr1 = new DefaultAttribute( atEMail ); + + assertEquals( 0, attr1.size() ); + assertFalse( attr1.contains( STR_VALUE1 ) ); + assertFalse( attr1.contains( NULL_STRING_VALUE ) ); + + attr1.add( ( String ) null ); + assertEquals( 1, attr1.size() ); + assertTrue( attr1.contains( NULL_STRING_VALUE ) ); + + attr1.remove( ( String ) null ); + assertFalse( attr1.contains( NULL_STRING_VALUE ) ); + assertEquals( 0, attr1.size() ); + + attr1.add( "a", "b", "c" ); + assertEquals( 3, attr1.size() ); + assertTrue( attr1.contains( STR_VALUE1 ) ); + assertTrue( attr1.contains( STR_VALUE2 ) ); + assertTrue( attr1.contains( STR_VALUE3 ) ); + assertTrue( attr1.contains( STR_VALUE1, STR_VALUE3 ) ); + assertFalse( attr1.contains( STR_VALUE4 ) ); + assertFalse( attr1.contains( NULL_STRING_VALUE ) ); + + Attribute attr2 = new DefaultAttribute( atPwd ); + assertEquals( 0, attr2.size() ); + assertFalse( attr2.contains( BYTES1 ) ); + assertFalse( attr2.contains( NULL_BINARY_VALUE ) ); + + attr2.add( ( byte[] ) null ); + assertEquals( 1, attr2.size() ); + assertTrue( attr2.contains( NULL_BINARY_VALUE ) ); + + attr2.remove( ( byte[] ) null ); + assertFalse( attr2.contains( NULL_BINARY_VALUE ) ); + assertEquals( 0, attr2.size() ); + + attr2.add( BYTES1, BYTES2, BYTES3 ); + assertEquals( 3, attr2.size() ); + assertTrue( attr2.contains( BIN_VALUE1 ) ); + assertTrue( attr2.contains( BIN_VALUE2 ) ); + assertTrue( attr2.contains( BIN_VALUE3 ) ); + assertFalse( attr2.contains( NULL_BINARY_VALUE ) ); + } + + + /** + * Test method contains( String... ) + */ + @Test + public void testContainsStringArray() throws LdapException + { + Attribute attr1 = new DefaultAttribute( atEMail ); + + assertEquals( 0, attr1.size() ); + assertFalse( attr1.contains( "a" ) ); + assertFalse( attr1.contains( ( String ) null ) ); + + attr1.add( ( String ) null ); + assertEquals( 1, attr1.size() ); + assertTrue( attr1.contains( ( String ) null ) ); + + attr1.remove( ( String ) null ); + assertFalse( attr1.contains( ( String ) null ) ); + assertEquals( 0, attr1.size() ); + + attr1.add( "a", "b", "c" ); + assertEquals( 3, attr1.size() ); + assertTrue( attr1.contains( "a" ) ); + assertTrue( attr1.contains( "b" ) ); + assertTrue( attr1.contains( "c" ) ); + assertFalse( attr1.contains( "e" ) ); + assertFalse( attr1.contains( ( String ) null ) ); + } + + + /** + * Test method contains( byte[]... ) + */ + @Test + public void testContainsByteArray() throws LdapException + { + Attribute attr1 = new DefaultAttribute( atPwd ); + + assertEquals( 0, attr1.size() ); + assertFalse( attr1.contains( BYTES1 ) ); + assertFalse( attr1.contains( ( byte[] ) null ) ); + + attr1.add( ( byte[] ) null ); + assertEquals( 1, attr1.size() ); + assertTrue( attr1.contains( ( byte[] ) null ) ); + + attr1.remove( ( byte[] ) null ); + assertFalse( attr1.contains( ( byte[] ) null ) ); + assertEquals( 0, attr1.size() ); + + attr1.add( BYTES1, BYTES2, BYTES3 ); + assertEquals( 3, attr1.size() ); + assertTrue( attr1.contains( BYTES1 ) ); + assertTrue( attr1.contains( BYTES2 ) ); + assertTrue( attr1.contains( BYTES3 ) ); + assertFalse( attr1.contains( BYTES4 ) ); + assertFalse( attr1.contains( ( byte[] ) null ) ); + } + + + /** + * Test method testEquals() + */ + @Test + public void testEquals() throws LdapException + { + Attribute attr1 = new DefaultAttribute( atCN ); + + assertFalse( attr1.equals( null ) ); + + Attribute attr2 = new DefaultAttribute( atCN ); + + assertTrue( attr1.equals( attr2 ) ); + + attr2.setUpId( "CN" ); + assertTrue( attr1.equals( attr2 ) ); + + attr1.setUpId( "CommonName" ); + assertTrue( attr1.equals( attr2 ) ); + + attr1.setUpId( "CN" ); + assertTrue( attr1.equals( attr2 ) ); + + attr1.add( "a", "b", "c" ); + attr2.add( "c", "b", "a" ); + assertTrue( attr1.equals( attr2 ) ); + + assertTrue( attr1.equals( attr2 ) ); + + Attribute attr3 = new DefaultAttribute( atPwd ); + Attribute attr4 = new DefaultAttribute( atPwd ); + + attr3.add( NULL_BINARY_VALUE ); + attr4.add( NULL_BINARY_VALUE ); + assertTrue( attr3.equals( attr4 ) ); + + Attribute attr5 = new DefaultAttribute( atPwd ); + Attribute attr6 = new DefaultAttribute( atDC ); + assertFalse( attr5.equals( attr6 ) ); + + attr5.add( NULL_BINARY_VALUE ); + attr6.add( NULL_STRING_VALUE ); + assertFalse( attr5.equals( attr6 ) ); + + Attribute attr7 = new DefaultAttribute( atCN ); + Attribute attr8 = new DefaultAttribute( atPwd ); + + attr7.add( "a" ); + attr8.add( BYTES2 ); + assertFalse( attr7.equals( attr8 ) ); + + Attribute attr9 = new DefaultAttribute( atCN ); + Attribute attr10 = new DefaultAttribute( atPwd ); + + attr9.add( "a" ); + attr9.add( BYTES2 ); + attr10.add( "a", "b" ); + assertFalse( attr9.equals( attr10 ) ); + + Attribute attr11 = new DefaultAttribute( atPwd, BYTES1 ); + Attribute attr12 = new DefaultAttribute( atPwd, BYTES1 ); + + assertTrue( attr11.get().equals( attr12.get() ) ); + assertTrue( attr12.get().equals( attr11.get() ) ); + + Attribute attr13 = new DefaultAttribute( "userPassword", BYTES1 ); + + assertTrue( attr11.get().equals( attr13.get() ) ); + assertTrue( attr13.get().equals( attr11.get() ) ); + + Attribute attr14 = new DefaultAttribute( "userPassword", BYTES1 ); + + assertTrue( attr14.get().equals( attr13.get() ) ); + assertTrue( attr13.get().equals( attr14.get() ) ); + } + + + /** + * Test method get() + */ + @Test + public void testGet() throws LdapException + { + Attribute attr1 = new DefaultAttribute( "dc", atDC ); + + attr1.add( ( String ) null ); + assertEquals( NULL_STRING_VALUE, attr1.get() ); + + Attribute attr2 = new DefaultAttribute( "email", atEMail ); + + attr2.add( "a", "b", "c" ); + assertEquals( "a", attr2.get().getString() ); + + attr2.remove( "a" ); + assertEquals( "b", attr2.get().getString() ); + + attr2.remove( "b" ); + assertEquals( "c", attr2.get().getString() ); + + attr2.remove( "c" ); + assertNull( attr2.get() ); + + Attribute attr3 = new DefaultAttribute( "userPassword", atPwd ); + + attr3.add( BYTES1, BYTES2, BYTES3 ); + assertTrue( Arrays.equals( BYTES1, attr3.get().getBytes() ) ); + + attr3.remove( BYTES1 ); + assertTrue( Arrays.equals( BYTES2, attr3.get().getBytes() ) ); + + attr3.remove( BYTES2 ); + assertTrue( Arrays.equals( BYTES3, attr3.get().getBytes() ) ); + + attr3.remove( BYTES3 ); + assertNull( attr2.get() ); + } + + + /** + * Test method getAll() + */ + @Test + public void testIterator2() throws LdapException + { + Attribute attr = new DefaultAttribute( atEMail ); + + Iterator> iterator = attr.iterator(); + assertFalse( iterator.hasNext() ); + + attr.add( NULL_STRING_VALUE ); + iterator = attr.iterator(); + assertTrue( iterator.hasNext() ); + + Value value = iterator.next(); + assertEquals( NULL_STRING_VALUE, value ); + + attr.clear(); + iterator = attr.iterator(); + assertFalse( iterator.hasNext() ); + + attr.add( "a", "b", "c" ); + iterator = attr.iterator(); + assertTrue( iterator.hasNext() ); + assertEquals( "a", iterator.next().getString() ); + assertEquals( "b", iterator.next().getString() ); + assertEquals( "c", iterator.next().getString() ); + assertFalse( iterator.hasNext() ); + } + + + /** + * Test method size() + */ + @Test + public void testSize() throws Exception + { + Attribute attr1 = new DefaultAttribute( atDC ); + + assertEquals( 0, attr1.size() ); + + attr1.add( ( String ) null ); + assertEquals( 1, attr1.size() ); + + Attribute attr2 = new DefaultAttribute( atCN ); + + attr2.add( "a", "b" ); + assertEquals( 2, attr2.size() ); + + attr2.clear(); + assertEquals( 0, attr2.size() ); + + Attribute attr3 = new DefaultAttribute( atC ); + + attr3.add( "US" ); + assertEquals( 1, attr3.size() ); + + // TODO : forbid addition of more than 1 value for SINGLE-VALUE attributes + attr3.add( "FR" ); + assertEquals( 1, attr3.size() ); + } + + + /** + * Test method put( byte[]... ) + */ + @Test + public void testPutByteArray() throws LdapException, Exception + { + Attribute attr1 = new DefaultAttribute( atPwd ); + + int nbAdded = attr1.add( ( byte[] ) null ); + assertEquals( 1, nbAdded ); + assertFalse( attr1.isHumanReadable() ); + assertTrue( Arrays.equals( NULL_BINARY_VALUE.getBytes(), attr1.getBytes() ) ); + + Attribute attr2 = new DefaultAttribute( atPwd ); + + nbAdded = attr2.add( StringConstants.EMPTY_BYTES ); + assertEquals( 1, nbAdded ); + assertFalse( attr2.isHumanReadable() ); + assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, attr2.getBytes() ) ); + + Attribute attr3 = new DefaultAttribute( atPwd ); + + nbAdded = attr3.add( BYTES1 ); + assertEquals( 1, nbAdded ); + assertFalse( attr3.isHumanReadable() ); + assertTrue( Arrays.equals( BYTES1, attr3.getBytes() ) ); + + Attribute attr4 = new DefaultAttribute( atPwd ); + + nbAdded = attr4.add( BYTES1, BYTES2 ); + assertEquals( 2, nbAdded ); + assertFalse( attr4.isHumanReadable() ); + assertTrue( attr4.contains( BYTES1 ) ); + assertTrue( attr4.contains( BYTES2 ) ); + + attr4.clear(); + nbAdded = attr4.add( BYTES3, BYTES4 ); + assertEquals( 2, nbAdded ); + assertFalse( attr4.isHumanReadable() ); + assertTrue( attr4.contains( BYTES3 ) ); + assertTrue( attr4.contains( BYTES4 ) ); + + Attribute attr5 = new DefaultAttribute( atPwd ); + + nbAdded = attr5.add( BYTES1, BYTES2, ( byte[] ) null, BYTES3 ); + assertEquals( 4, nbAdded ); + assertFalse( attr5.isHumanReadable() ); + assertTrue( attr5.contains( BYTES1 ) ); + assertTrue( attr5.contains( BYTES2 ) ); + assertTrue( attr5.contains( ( byte[] ) null ) ); + assertTrue( attr5.contains( BYTES3 ) ); + + Attribute attr6 = new DefaultAttribute( atPwd ); + + assertFalse( attr6.isHumanReadable() ); + nbAdded = attr6.add( BYTES1, ( byte[] ) null ); + assertEquals( 2, nbAdded ); + assertTrue( attr6.contains( BYTES1 ) ); + assertTrue( attr6.contains( ( byte[] ) null ) ); + } + + + /** + * Test method put( String... ) + */ + @Test + public void testPutStringArray() throws LdapInvalidAttributeValueException + { + Attribute attr1 = new DefaultAttribute( atDC ); + + int nbAdded = attr1.add( ( String ) null ); + assertEquals( 1, nbAdded ); + assertTrue( attr1.isHumanReadable() ); + assertEquals( NULL_STRING_VALUE, attr1.get() ); + + Attribute attr2 = new DefaultAttribute( atDC ); + + nbAdded = attr2.add( "" ); + assertEquals( 1, nbAdded ); + assertTrue( attr2.isHumanReadable() ); + assertEquals( "", attr2.getString() ); + + Attribute attr3 = new DefaultAttribute( atDC ); + + nbAdded = attr3.add( "t" ); + assertEquals( 1, nbAdded ); + assertTrue( attr3.isHumanReadable() ); + assertEquals( "t", attr3.getString() ); + + Attribute attr4 = new DefaultAttribute( atEMail ); + + nbAdded = attr4.add( "a", "b", "c", "d" ); + assertEquals( 4, nbAdded ); + assertTrue( attr4.isHumanReadable() ); + assertEquals( "a", attr4.getString() ); + assertTrue( attr4.contains( "a" ) ); + assertTrue( attr4.contains( "b" ) ); + assertTrue( attr4.contains( "c" ) ); + assertTrue( attr4.contains( "d" ) ); + + attr4.clear(); + nbAdded = attr4.add( "e" ); + assertEquals( 1, nbAdded ); + assertTrue( attr4.isHumanReadable() ); + assertEquals( "e", attr4.getString() ); + assertFalse( attr4.contains( "a" ) ); + assertFalse( attr4.contains( "b" ) ); + assertFalse( attr4.contains( "c" ) ); + assertFalse( attr4.contains( "d" ) ); + assertTrue( attr4.contains( "e" ) ); + + attr4.clear(); + nbAdded = attr4.add( BYTES1 ); + assertEquals( 0, nbAdded ); + assertTrue( attr4.isHumanReadable() ); + + Attribute attr5 = new DefaultAttribute( atEMail ); + + nbAdded = attr5.add( "a", "b", ( String ) null, "d" ); + assertEquals( 4, nbAdded ); + assertTrue( attr5.isHumanReadable() ); + assertTrue( attr5.contains( "a" ) ); + assertTrue( attr5.contains( "b" ) ); + assertTrue( attr5.contains( NULL_STRING_VALUE ) ); + assertTrue( attr5.contains( "d" ) ); + + Attribute attr6 = new DefaultAttribute( atPwd ); + + nbAdded = attr6.add( "a", ( String ) null ); + assertEquals( 2, nbAdded ); + assertFalse( attr6.isHumanReadable() ); + } + + + /** + * Test method put( Value... ) + */ + @Test + public void testPutValueArray() throws Exception + { + Attribute attr1 = new DefaultAttribute( atDC ); + + assertEquals( 0, attr1.size() ); + + attr1.add( NULL_STRING_VALUE ); + assertEquals( 1, attr1.size() ); + assertTrue( attr1.contains( NULL_STRING_VALUE ) ); + + attr1.clear(); + attr1.add( STR_VALUE1, STR_VALUE2, STR_VALUE3 ); + assertEquals( 3, attr1.size() ); + assertTrue( attr1.contains( STR_VALUE1 ) ); + assertTrue( attr1.contains( STR_VALUE2 ) ); + assertTrue( attr1.contains( STR_VALUE3 ) ); + + attr1.clear(); + attr1.add( STR_VALUE1, NULL_STRING_VALUE, STR_VALUE3 ); + assertEquals( 3, attr1.size() ); + assertTrue( attr1.contains( STR_VALUE1 ) ); + assertTrue( attr1.contains( NULL_STRING_VALUE ) ); + assertTrue( attr1.contains( STR_VALUE3 ) ); + + attr1.clear(); + attr1.add( STR_VALUE1, NULL_STRING_VALUE, BIN_VALUE3 ); + assertEquals( 2, attr1.size() ); + assertTrue( attr1.contains( STR_VALUE1 ) ); + assertTrue( attr1.contains( NULL_STRING_VALUE ) ); + assertFalse( attr1.contains( STR_VALUE3 ) ); + + Attribute attr2 = new DefaultAttribute( atPwd ); + assertEquals( 0, attr2.size() ); + + attr2.add( NULL_BINARY_VALUE ); + assertEquals( 1, attr2.size() ); + assertTrue( attr2.contains( NULL_BINARY_VALUE ) ); + + attr2.clear(); + attr2.add( BIN_VALUE1, BIN_VALUE2, BIN_VALUE3 ); + assertEquals( 3, attr2.size() ); + assertTrue( attr2.contains( BIN_VALUE1 ) ); + assertTrue( attr2.contains( BIN_VALUE2 ) ); + assertTrue( attr2.contains( BIN_VALUE3 ) ); + + attr2.clear(); + attr2.add( BIN_VALUE1, NULL_BINARY_VALUE, STR_VALUE3 ); + assertEquals( 2, attr2.size() ); + assertTrue( attr2.contains( BIN_VALUE1 ) ); + assertTrue( attr2.contains( NULL_BINARY_VALUE ) ); + assertFalse( attr2.contains( BIN_VALUE3 ) ); + } + + + /** + * Test method remove( Value... ) + */ + @Test + public void testRemoveValueArray() throws Exception + { + Attribute attr1 = new DefaultAttribute( atEMail ); + + assertFalse( attr1.remove( STR_VALUE1 ) ); + + attr1.add( "a", "b", "c" ); + assertTrue( attr1.remove( STR_VALUE1 ) ); + assertEquals( 2, attr1.size() ); + + assertTrue( attr1.remove( STR_VALUE2, STR_VALUE3 ) ); + assertEquals( 0, attr1.size() ); + + assertFalse( attr1.remove( STR_VALUE4 ) ); + + attr1.clear(); + attr1.add( "a", "b", "c" ); + assertFalse( attr1.remove( STR_VALUE2, STR_VALUE4 ) ); + assertEquals( 2, attr1.size() ); + + attr1.clear(); + attr1.add( "a", ( String ) null, "b" ); + assertTrue( attr1.remove( NULL_STRING_VALUE, STR_VALUE1 ) ); + assertEquals( 1, attr1.size() ); + + attr1.clear(); + attr1.add( "a", ( String ) null, "b" ); + attr1.add( BYTES3 ); + assertFalse( attr1.remove( NULL_STRING_VALUE, STR_VALUE1, BIN_VALUE3 ) ); + assertEquals( 1, attr1.size() ); + + Attribute attr2 = new DefaultAttribute( atPwd ); + + assertFalse( attr2.remove( BIN_VALUE1 ) ); + + attr2.add( BYTES1, BYTES2, BYTES3 ); + assertTrue( attr2.remove( BIN_VALUE1 ) ); + assertEquals( 2, attr2.size() ); + + assertTrue( attr2.remove( BIN_VALUE2, BIN_VALUE3 ) ); + assertEquals( 0, attr2.size() ); + + assertFalse( attr2.remove( BIN_VALUE4 ) ); + + attr2.clear(); + attr2.add( BYTES1, BYTES2, BYTES3 ); + assertFalse( attr2.remove( BIN_VALUE2, STR_VALUE4 ) ); + assertEquals( 2, attr2.size() ); + + attr2.clear(); + attr2.add( BYTES1, ( byte[] ) null, BYTES3 ); + assertFalse( attr2.remove( NULL_STRING_VALUE, BIN_VALUE1 ) ); + assertEquals( 2, attr2.size() ); + + attr2.clear(); + attr2.add( BYTES1, ( byte[] ) null, BYTES2 ); + attr2.add( "c" ); + assertEquals( 4, attr2.size() ); + assertFalse( attr2.remove( NULL_STRING_VALUE, BIN_VALUE1, STR_VALUE3 ) ); + assertEquals( 3, attr2.size() ); + } + + + /** + * Test method remove( byte... ) + */ + @Test + public void testRemoveByteArray() throws Exception + { + Attribute attr1 = new DefaultAttribute( atPwd ); + + assertFalse( attr1.remove( BYTES1 ) ); + + attr1.add( BYTES1, BYTES2, BYTES3 ); + assertTrue( attr1.remove( BYTES1 ) ); + assertEquals( 2, attr1.size() ); + + assertTrue( attr1.remove( BYTES2, BYTES3 ) ); + assertEquals( 0, attr1.size() ); + + assertFalse( attr1.remove( BYTES4 ) ); + + attr1.clear(); + attr1.add( BYTES1, BYTES2, BYTES3 ); + assertFalse( attr1.remove( BYTES3, BYTES4 ) ); + assertEquals( 2, attr1.size() ); + + attr1.clear(); + attr1.add( BYTES1, ( byte[] ) null, BYTES2 ); + assertTrue( attr1.remove( ( byte[] ) null, BYTES1 ) ); + assertEquals( 1, attr1.size() ); + } + + + /** + * Test method remove( String... ) + */ + @Test + public void testRemoveStringArray() throws Exception + { + Attribute attr1 = new DefaultAttribute( atEMail ); + + assertFalse( attr1.remove( "a" ) ); + + attr1.add( "a", "b", "c" ); + assertTrue( attr1.remove( "a" ) ); + assertEquals( 2, attr1.size() ); + + assertTrue( attr1.remove( "b", "c" ) ); + assertEquals( 0, attr1.size() ); + + assertFalse( attr1.remove( "d" ) ); + + attr1.clear(); + attr1.add( "a", "b", "c" ); + assertFalse( attr1.remove( "b", "e" ) ); + assertEquals( 2, attr1.size() ); + + attr1.clear(); + attr1.add( "a", ( String ) null, "b" ); + assertTrue( attr1.remove( ( String ) null, "a" ) ); + assertEquals( 1, attr1.size() ); + + Attribute attr2 = new DefaultAttribute( "test" ); + + attr2.add( BYTES1, BYTES2, BYTES3 ); + + assertFalse( attr2.remove( ( String ) null ) ); + assertTrue( attr2.remove( "ab", "c" ) ); + assertFalse( attr2.remove( "d" ) ); + } + + + /** + * Test method iterator() + */ + @Test + public void testIterator() throws LdapException + { + Attribute attr1 = new DefaultAttribute( atCN ); + attr1.add( "a", "b", "c" ); + + Iterator> iter = attr1.iterator(); + + assertTrue( iter.hasNext() ); + + String[] values = new String[] + { "a", "b", "c" }; + int pos = 0; + + for ( Value val : attr1 ) + { + assertTrue( val instanceof StringValue ); + assertEquals( values[pos++], val.getString() ); + } + } + + + /** + * Test method toString + */ + @Test + public void testToString() throws LdapException + { + Attribute attr = new DefaultAttribute( atEMail ); + + assertEquals( "email: (null)\n", attr.toString() ); + + attr.setUpId( "EMail" ); + assertEquals( "EMail: (null)\n", attr.toString() ); + + attr.add( ( String ) null ); + assertEquals( "EMail: ''\n", attr.toString() ); + + attr.clear(); + attr.add( "a", "b" ); + assertEquals( "EMail: a\nEMail: b\n", attr.toString() ); + } + + + /** + * Test method instanceOf() + */ + @Test + public void testInstanceOf() throws Exception + { + Attribute attr = new DefaultAttribute( atCN ); + + assertTrue( attr.isInstanceOf( atCN ) ); + assertTrue( attr.isInstanceOf( atName ) ); + assertFalse( attr.isInstanceOf( atSN ) ); + } + + + /** + * Test method setUpId( String, AttributeType ) + */ + @Test + public void testSetUpIdStringAttributeType() throws Exception + { + Attribute attr = new DefaultAttribute( atSN ); + + attr.setUpId( null, atCN ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "cn", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + + attr.setUpId( " ", atCN ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "cn", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + + attr.setUpId( " CN ", atCN ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( " CN ", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + + attr.setUpId( " CommonName ", atCN ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( " CommonName ", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + + attr.setUpId( " 2.5.4.3 ", atCN ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( " 2.5.4.3 ", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + + // Check with wrong IDs + try + { + attr.setUpId( "sn", atCN ); + fail(); + } + catch ( IllegalArgumentException iae ) + { + assertTrue( true ); + } + + try + { + attr.setUpId( " 2.5.4.4 ", atCN ); + fail(); + } + catch ( IllegalArgumentException iae ) + { + assertTrue( true ); + } + } + + + /** + * Test method setUpId( String ) inherited from ClientAttribute + */ + @Test + public void testSetUpIdString() throws Exception + { + Attribute attr = new DefaultAttribute( atCN ); + + attr.setUpId( "cn" ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "cn", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + + attr.setUpId( " CN " ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( " CN ", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + + attr.setUpId( " CommonName " ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( " CommonName ", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + + attr.setUpId( " 2.5.4.3 " ); + assertEquals( " 2.5.4.3 ", attr.getUpId() ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( atCN, attr.getAttributeType() ); + + // Now check wrong IDs + attr = new DefaultAttribute( atCN ); + + try + { + attr.setUpId( "sn" ); + fail(); + } + catch ( IllegalArgumentException iae ) + { + // Expected + } + + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "cn", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + + try + { + attr.setUpId( " SN " ); + fail(); + } + catch ( IllegalArgumentException iae ) + { + // Expected + } + + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "cn", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + + try + { + attr.setUpId( " surname " ); + fail(); + } + catch ( IllegalArgumentException iae ) + { + // Expected + } + + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "cn", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + + try + { + attr.setUpId( " 2.5.4.4 " ); + fail(); + } + catch ( IllegalArgumentException iae ) + { + // Expected + } + + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "cn", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + } + + + /** + * Test method setAttributeType( AttributeType ) + */ + @Test + public void testSetAttributeType() throws Exception + { + Attribute attr = new DefaultAttribute( atCN ); + + try + { + attr.apply( null ); + fail(); + } + catch ( IllegalArgumentException iae ) + { + assertTrue( true ); + } + + attr.apply( atSN ); + + assertTrue( attr.isInstanceOf( atSN ) ); + assertEquals( "2.5.4.4", attr.getId() ); + assertEquals( "sn", attr.getUpId() ); + } + + + /** + * Test method getAttributeType() + */ + @Test + public void testGetAttributeType() throws Exception + { + Attribute attr = new DefaultAttribute( atSN ); + assertEquals( atSN, attr.getAttributeType() ); + } + + + /** + * Test constructor DefaultEntryAttribute( AttributeType ) + */ + @Test + public void testDefaultServerAttributeAttributeType() + { + Attribute attr = new DefaultAttribute( atCN ); + + assertTrue( attr.isHumanReadable() ); + assertEquals( 0, attr.size() ); + assertEquals( "2.5.4.3", attr.getId() ); + assertEquals( "cn", attr.getUpId() ); + assertEquals( atCN, attr.getAttributeType() ); + } + + + /** + * Test constructor DefaultEntryAttribute( String, AttributeType ) + */ + @Test + public void testDefaultServerAttributeStringAttributeType() + { + Attribute attr1 = new DefaultAttribute( "cn", atCN ); + + assertTrue( attr1.isHumanReadable() ); + assertEquals( 0, attr1.size() ); + assertEquals( "2.5.4.3", attr1.getId() ); + assertEquals( "cn", attr1.getUpId() ); + assertEquals( atCN, attr1.getAttributeType() ); + + Attribute attr2 = new DefaultAttribute( " CommonName ", atCN ); + + assertTrue( attr2.isHumanReadable() ); + assertEquals( 0, attr2.size() ); + assertEquals( "2.5.4.3", attr2.getId() ); + assertEquals( " CommonName ", attr2.getUpId() ); + assertEquals( atCN, attr2.getAttributeType() ); + + Attribute attr3 = new DefaultAttribute( " ", atCN ); + + assertTrue( attr3.isHumanReadable() ); + assertEquals( 0, attr3.size() ); + assertEquals( "2.5.4.3", attr3.getId() ); + assertEquals( "cn", attr3.getUpId() ); + assertEquals( atCN, attr3.getAttributeType() ); + } + + + /** + * Test constructor DefaultEntryAttribute( AttributeType, Value... ) + */ + @Test + public void testDefaultServerAttributeAttributeTypeValueArray() throws Exception + { + Attribute attr1 = new DefaultAttribute( atDC, STR_VALUE1, STR_VALUE2, NULL_STRING_VALUE ); + + assertTrue( attr1.isHumanReadable() ); + assertEquals( 3, attr1.size() ); + assertEquals( "0.9.2342.19200300.100.1.25", attr1.getId() ); + assertEquals( "dc", attr1.getUpId() ); + assertEquals( atDC, attr1.getAttributeType() ); + assertTrue( attr1.contains( "a", "b" ) ); + assertTrue( attr1.contains( NULL_STRING_VALUE ) ); + + Attribute attr2 = new DefaultAttribute( atDC, STR_VALUE1, BIN_VALUE2, NULL_STRING_VALUE ); + + assertTrue( attr2.isHumanReadable() ); + assertEquals( 2, attr2.size() ); + assertEquals( "0.9.2342.19200300.100.1.25", attr2.getId() ); + assertEquals( "dc", attr2.getUpId() ); + assertEquals( atDC, attr2.getAttributeType() ); + assertTrue( attr2.contains( "a" ) ); + assertTrue( attr2.contains( NULL_STRING_VALUE ) ); + } + + + /** + * Test constructor DefaultEntryAttribute( String, AttributeType, Value... ) + */ + @Test + public void testDefaultServerAttributeStringAttributeTypeValueArray() throws LdapException + { + Attribute attr1 = new DefaultAttribute( "dc", atDC, STR_VALUE1, STR_VALUE2, NULL_STRING_VALUE ); + + assertTrue( attr1.isHumanReadable() ); + assertEquals( 3, attr1.size() ); + assertEquals( "0.9.2342.19200300.100.1.25", attr1.getId() ); + assertEquals( "dc", attr1.getUpId() ); + assertEquals( atDC, attr1.getAttributeType() ); + assertTrue( attr1.contains( "a", "b" ) ); + assertTrue( attr1.contains( NULL_STRING_VALUE ) ); + + Attribute attr2 = new DefaultAttribute( atDC, STR_VALUE1, BIN_VALUE2, NULL_STRING_VALUE ); + + assertTrue( attr2.isHumanReadable() ); + assertEquals( 2, attr2.size() ); + assertEquals( "0.9.2342.19200300.100.1.25", attr2.getId() ); + assertEquals( "dc", attr2.getUpId() ); + assertEquals( atDC, attr2.getAttributeType() ); + assertTrue( attr2.contains( "a" ) ); + assertTrue( attr2.contains( NULL_STRING_VALUE ) ); + + Attribute attr3 = new DefaultAttribute( "DomainComponent", atDC, STR_VALUE1, STR_VALUE2, + NULL_STRING_VALUE ); + + assertTrue( attr3.isHumanReadable() ); + assertEquals( 3, attr3.size() ); + assertEquals( "0.9.2342.19200300.100.1.25", attr3.getId() ); + assertEquals( "DomainComponent", attr3.getUpId() ); + assertEquals( atDC, attr3.getAttributeType() ); + assertTrue( attr3.contains( "a", "b" ) ); + assertTrue( attr3.contains( NULL_STRING_VALUE ) ); + + Attribute attr4 = new DefaultAttribute( " 0.9.2342.19200300.100.1.25 ", atDC, STR_VALUE1, STR_VALUE2, + NULL_STRING_VALUE ); + + assertTrue( attr4.isHumanReadable() ); + assertEquals( 3, attr4.size() ); + assertEquals( "0.9.2342.19200300.100.1.25", attr4.getId() ); + assertEquals( " 0.9.2342.19200300.100.1.25 ", attr4.getUpId() ); + assertEquals( atDC, attr4.getAttributeType() ); + assertTrue( attr4.contains( "a", "b" ) ); + assertTrue( attr4.contains( NULL_STRING_VALUE ) ); + } + + + /** + * Test constructor DefaultEntryAttribute( AttributeType, String... ) + */ + @Test + public void testDefaultServerAttributeAttributeTypeStringArray() throws LdapException + { + Attribute attr1 = new DefaultAttribute( atEMail, "a", "b", ( String ) null ); + + assertTrue( attr1.isHumanReadable() ); + assertEquals( 3, attr1.size() ); + assertEquals( "1.2.840.113549.1.9.1", attr1.getId() ); + assertEquals( "email", attr1.getUpId() ); + assertEquals( atEMail, attr1.getAttributeType() ); + assertTrue( attr1.contains( "a", "b" ) ); + assertTrue( attr1.contains( NULL_STRING_VALUE ) ); + + Attribute attr2 = new DefaultAttribute( atEMail, STR_VALUE1, BIN_VALUE2, NULL_STRING_VALUE ); + + assertTrue( attr2.isHumanReadable() ); + assertEquals( 2, attr2.size() ); + assertEquals( "1.2.840.113549.1.9.1", attr2.getId() ); + assertEquals( "email", attr2.getUpId() ); + assertEquals( atEMail, attr2.getAttributeType() ); + assertTrue( attr2.contains( "a" ) ); + assertTrue( attr2.contains( NULL_STRING_VALUE ) ); + } + + + /** + * Test constructor DefaultEntryAttribute( String, AttributeType, String... ) + */ + @Test + public void testDefaultServerAttributeStringAttributeTypeStringArray() throws LdapException + { + Attribute attr1 = new DefaultAttribute( "email", atEMail, "a", "b", ( String ) null ); + + assertTrue( attr1.isHumanReadable() ); + assertEquals( 3, attr1.size() ); + assertEquals( "1.2.840.113549.1.9.1", attr1.getId() ); + assertEquals( "email", attr1.getUpId() ); + assertEquals( atEMail, attr1.getAttributeType() ); + assertTrue( attr1.contains( "a", "b" ) ); + assertTrue( attr1.contains( NULL_STRING_VALUE ) ); + + Attribute attr2 = new DefaultAttribute( "EMail", atEMail, "a", "b", ( String ) null ); + + assertTrue( attr2.isHumanReadable() ); + assertEquals( 3, attr2.size() ); + assertEquals( "1.2.840.113549.1.9.1", attr2.getId() ); + assertEquals( "EMail", attr2.getUpId() ); + assertEquals( atEMail, attr2.getAttributeType() ); + assertTrue( attr2.contains( "a", "b" ) ); + assertTrue( attr2.contains( NULL_STRING_VALUE ) ); + + Attribute attr3 = new DefaultAttribute( " 1.2.840.113549.1.9.1 ", atEMail, "a", "b", + ( String ) null ); + + assertTrue( attr3.isHumanReadable() ); + assertEquals( 3, attr3.size() ); + assertEquals( "1.2.840.113549.1.9.1", attr3.getId() ); + assertEquals( " 1.2.840.113549.1.9.1 ", attr3.getUpId() ); + assertEquals( atEMail, attr3.getAttributeType() ); + assertTrue( attr3.contains( "a", "b" ) ); + assertTrue( attr3.contains( NULL_STRING_VALUE ) ); + } + + + /** + * Test method DefaultEntryAttribute( AttributeType, byte[]... ) + */ + @Test + public void testDefaultServerAttributeAttributeTypeByteArray() throws LdapException + { + Attribute attr1 = new DefaultAttribute( atPwd, BYTES1, BYTES2, ( byte[] ) null ); + + assertFalse( attr1.isHumanReadable() ); + assertEquals( 3, attr1.size() ); + assertEquals( "2.5.4.35", attr1.getId() ); + assertEquals( "userPassword", attr1.getUpId() ); + assertEquals( atPwd, attr1.getAttributeType() ); + assertTrue( attr1.contains( BYTES1, BYTES2 ) ); + assertTrue( attr1.contains( NULL_BINARY_VALUE ) ); + + Attribute attr2 = new DefaultAttribute( atPwd, STR_VALUE1, BIN_VALUE2, NULL_BINARY_VALUE ); + + assertFalse( attr2.isHumanReadable() ); + assertEquals( 2, attr2.size() ); + assertEquals( "2.5.4.35", attr2.getId() ); + assertEquals( "userPassword", attr2.getUpId() ); + assertEquals( atPwd, attr2.getAttributeType() ); + assertTrue( attr2.contains( BYTES2 ) ); + assertTrue( attr2.contains( NULL_BINARY_VALUE ) ); + } + + + /** + * Test method DefaultEntryAttribute( String, AttributeType, byte[]... ) + */ + @Test + public void testDefaultServerAttributeStringAttributeTypeByteArray() throws LdapException + { + Attribute attr1 = new DefaultAttribute( "userPassword", atPwd, BYTES1, BYTES2, ( byte[] ) null ); + + assertFalse( attr1.isHumanReadable() ); + assertEquals( 3, attr1.size() ); + assertEquals( "2.5.4.35", attr1.getId() ); + assertEquals( "userPassword", attr1.getUpId() ); + assertEquals( atPwd, attr1.getAttributeType() ); + assertTrue( attr1.contains( BYTES1, BYTES2 ) ); + assertTrue( attr1.contains( NULL_BINARY_VALUE ) ); + + Attribute attr2 = new DefaultAttribute( "2.5.4.35", atPwd, STR_VALUE1, BIN_VALUE2, NULL_BINARY_VALUE ); + + assertFalse( attr2.isHumanReadable() ); + assertEquals( 2, attr2.size() ); + assertEquals( "2.5.4.35", attr2.getId() ); + assertEquals( "2.5.4.35", attr2.getUpId() ); + assertEquals( atPwd, attr2.getAttributeType() ); + assertTrue( attr2.contains( BYTES2 ) ); + assertTrue( attr2.contains( NULL_BINARY_VALUE ) ); + } + + + /** + * Test method testClone() + */ + @Test + public void testClone() throws LdapException + { + Attribute attr = new DefaultAttribute( atDC ); + + Attribute clone = attr.clone(); + + assertEquals( attr, clone ); + attr.setUpId( "DomainComponent" ); + assertEquals( "0.9.2342.19200300.100.1.25", clone.getId() ); + + attr.add( "a", ( String ) null, "b" ); + clone = attr.clone(); + assertEquals( attr, clone ); + + attr.remove( "a" ); + assertNotSame( attr, clone ); + + clone = attr.clone(); + assertEquals( attr, clone ); + } + + + /** + * Test the copy constructor of a EntryAttribute + */ + @Test + public void testCopyConstructorServerAttribute() throws LdapException + { + Attribute attribute = new DefaultAttribute( atCN ); + + Attribute copy = new DefaultAttribute( atCN, attribute ); + + assertEquals( copy, attribute ); + + Attribute attribute2 = new DefaultAttribute( atCN, "test" ); + + Attribute copy2 = new DefaultAttribute( atCN, attribute2 ); + + assertEquals( copy2, attribute2 ); + attribute2.add( "test2" ); + assertNotSame( copy2, attribute2 ); + assertEquals( "test", copy2.getString() ); + } + + + /** + * Test the copy constructor of a ClientAttribute + */ + @Test + public void testCopyConstructorClientAttribute() throws LdapException + { + Attribute attribute = new DefaultAttribute( "commonName" ); + attribute.add( "test" ); + + Attribute copy = new DefaultAttribute( atCN, attribute ); + + assertEquals( atCN, copy.getAttributeType() ); + assertEquals( "test", copy.getString() ); + assertTrue( copy.isHumanReadable() ); + + attribute.add( "test2" ); + assertFalse( copy.contains( "test2" ) ); + } + + + /** + * Test the conversion method + */ + @Test + public void testToClientAttribute() throws LdapException + { + Attribute attribute = new DefaultAttribute( atCN, "test", "test2" ); + + Attribute clientAttribute = attribute.clone(); + + assertTrue( clientAttribute instanceof Attribute ); + + assertTrue( clientAttribute.contains( "test", "test2" ) ); + assertEquals( "2.5.4.3", clientAttribute.getId() ); + + attribute.remove( "test", "test2" ); + assertTrue( clientAttribute.contains( "test", "test2" ) ); + } + + + /** + * Test the serialization of a complete server attribute + */ + @Test + public void testSerializeCompleteAttribute() throws LdapException, IOException, ClassNotFoundException + { + DefaultAttribute dsa = new DefaultAttribute( atCN ); + dsa.setUpId( "CommonName" ); + dsa.add( "test1", "test2" ); + + DefaultAttribute dsaSer = deserializeValue( serializeValue( dsa ), atCN ); + assertEquals( dsa.toString(), dsaSer.toString() ); + assertEquals( "2.5.4.3", dsaSer.getId() ); + assertEquals( "CommonName", dsaSer.getUpId() ); + assertEquals( "test1", dsaSer.getString() ); + assertTrue( dsaSer.contains( "test2", "test1" ) ); + assertTrue( dsaSer.isHumanReadable() ); + } + + + /** + * Test the serialization of a server attribute with no value + */ + @Test + public void testSerializeAttributeWithNoValue() throws LdapException, IOException, ClassNotFoundException + { + DefaultAttribute dsa = new DefaultAttribute( atCN ); + dsa.setUpId( "cn" ); + + DefaultAttribute dsaSer = deserializeValue( serializeValue( dsa ), atCN ); + assertEquals( dsa.toString(), dsaSer.toString() ); + assertEquals( "2.5.4.3", dsaSer.getId() ); + assertEquals( "cn", dsaSer.getUpId() ); + assertEquals( 0, dsaSer.size() ); + assertTrue( dsaSer.isHumanReadable() ); + } + + + /** + * Test the serialization of a server attribute with a null value + */ + @Test + public void testSerializeAttributeNullValue() throws LdapException, IOException, ClassNotFoundException + { + DefaultAttribute dsa = new DefaultAttribute( atDC ); + dsa.setUpId( "DomainComponent" ); + dsa.add( ( String ) null ); + + DefaultAttribute dsaSer = deserializeValue( serializeValue( dsa ), atDC ); + assertEquals( dsa.toString(), dsaSer.toString() ); + assertEquals( "0.9.2342.19200300.100.1.25", dsaSer.getId() ); + assertEquals( "DomainComponent", dsaSer.getUpId() ); + assertEquals( "", dsaSer.getString() ); + assertEquals( 1, dsaSer.size() ); + assertTrue( dsaSer.contains( ( String ) null ) ); + assertTrue( dsaSer.isHumanReadable() ); + } + + + /** + * Test the serialization of a server attribute with a binary value + */ + @Test + public void testSerializeAttributeBinaryValue() throws LdapException, IOException, ClassNotFoundException + { + DefaultAttribute dsa = new DefaultAttribute( atPwd ); + byte[] password = Strings.getBytesUtf8( "secret" ); + dsa.add( password ); + + DefaultAttribute dsaSer = deserializeValue( serializeValue( dsa ), atPwd ); + assertEquals( dsa.toString(), dsaSer.toString() ); + assertEquals( "2.5.4.35", dsaSer.getId() ); + assertEquals( "userPassword", dsaSer.getUpId() ); + assertTrue( Arrays.equals( dsa.getBytes(), dsaSer.getBytes() ) ); + assertEquals( 1, dsaSer.size() ); + assertTrue( dsaSer.contains( password ) ); + assertFalse( dsaSer.isHumanReadable() ); + } +} Propchange: directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareAttributeTest.java ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareEntrySerializationTest.java URL: http://svn.apache.org/viewvc/directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareEntrySerializationTest.java?rev=1423968&view=auto ============================================================================== --- directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareEntrySerializationTest.java (added) +++ directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareEntrySerializationTest.java Wed Dec 19 17:24:08 2012 @@ -0,0 +1,170 @@ +/* + * 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.api.ldap.entry; + + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; + +import org.apache.directory.api.ldap.model.entry.DefaultEntry; +import org.apache.directory.api.ldap.model.entry.Entry; +import org.apache.directory.api.ldap.model.exception.LdapException; +import org.apache.directory.api.ldap.model.schema.SchemaManager; +import org.apache.directory.shared.ldap.schemamanager.impl.DefaultSchemaManager; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.mycila.junit.concurrent.Concurrency; +import com.mycila.junit.concurrent.ConcurrentJunitRunner; + + +/** + * Test the Entry Serialization + * + * @author Apache Directory Project + */ +@RunWith(ConcurrentJunitRunner.class) +@Concurrency() +public class SchemaAwareEntrySerializationTest +{ + private static SchemaManager schemaManager; + + + /** + * Initialize OIDs maps for normalization + */ + @BeforeClass + public static void setup() throws Exception + { + schemaManager = new DefaultSchemaManager(); + } + + + @Test + public void testEntryFullSerialization() throws IOException, LdapException, ClassNotFoundException + { + Entry entry1 = new DefaultEntry( + schemaManager, + "dc=example, dc=com", + "ObjectClass: top", + "ObjectClass: domain", + "dc: example", + "l: test" ); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream( baos ); + + entry1.writeExternal( out ); + + ObjectInputStream in = null; + + byte[] data = baos.toByteArray(); + in = new ObjectInputStream( new ByteArrayInputStream( data ) ); + + Entry entry2 = new DefaultEntry( schemaManager ); + entry2.readExternal( in ); + + assertEquals( entry1, entry2 ); + assertTrue( entry2.contains( "2.5.4.0", "top", "domain" ) ); + } + + + @Test + public void testEntryNoDnSerialization() throws IOException, LdapException, ClassNotFoundException + { + Entry entry1 = new DefaultEntry( + schemaManager, + "", + "ObjectClass: top", + "ObjectClass: domain", + "dc: example", + "l: test" ); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream( baos ); + + entry1.writeExternal( out ); + + ObjectInputStream in = null; + + byte[] data = baos.toByteArray(); + in = new ObjectInputStream( new ByteArrayInputStream( data ) ); + + Entry entry2 = new DefaultEntry( schemaManager ); + entry2.readExternal( in ); + + assertEquals( entry1, entry2 ); + assertTrue( entry2.contains( "ObjectClass", "top", "domain" ) ); + assertEquals( "", entry2.getDn().toString() ); + } + + + @Test + public void testEntryNoAttributesSerialization() throws IOException, LdapException, ClassNotFoundException + { + Entry entry1 = new DefaultEntry( schemaManager, "dc=example, dc=com" ); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream( baos ); + + entry1.writeExternal( out ); + + ObjectInputStream in = null; + + byte[] data = baos.toByteArray(); + in = new ObjectInputStream( new ByteArrayInputStream( data ) ); + + Entry entry2 = new DefaultEntry( schemaManager ); + entry2.readExternal( in ); + + assertEquals( entry1, entry2 ); + assertEquals( 0, entry2.size() ); + } + + + @Test + public void testEntryNoAttributesNoDnSerialization() throws IOException, LdapException, ClassNotFoundException + { + Entry entry1 = new DefaultEntry( schemaManager, "" ); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream( baos ); + + entry1.writeExternal( out ); + + ObjectInputStream in = null; + + byte[] data = baos.toByteArray(); + in = new ObjectInputStream( new ByteArrayInputStream( data ) ); + + Entry entry2 = new DefaultEntry( schemaManager ); + entry2.readExternal( in ); + + assertEquals( entry1, entry2 ); + assertEquals( 0, entry2.size() ); + } +} Propchange: directory/shared/branches/shared-refact/integ/src/test/java/org/apache/directory/api/ldap/entry/SchemaAwareEntrySerializationTest.java ------------------------------------------------------------------------------ svn:mime-type = text/plain