/*
* 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.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.List;
import java.util.Set;
import org.apache.directory.shared.ldap.model.entry.Attribute;
import org.apache.directory.shared.ldap.model.entry.BinaryValue;
import org.apache.directory.shared.ldap.model.entry.DefaultAttribute;
import org.apache.directory.shared.ldap.model.entry.DefaultEntry;
import org.apache.directory.shared.ldap.model.entry.Entry;
import org.apache.directory.shared.ldap.model.entry.StringValue;
import org.apache.directory.shared.ldap.model.entry.Value;
import org.apache.directory.shared.ldap.model.exception.LdapException;
import org.apache.directory.shared.ldap.model.name.Dn;
import org.apache.directory.shared.ldap.model.schema.SchemaManager;
import org.apache.directory.shared.ldap.schemamanager.impl.DefaultSchemaManager;
import org.apache.directory.shared.util.Strings;
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;
/**
* A test class for the DefaultEntry class
*
* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
*/
@RunWith(ConcurrentJunitRunner.class)
@Concurrency()
public class SchemaAwareEntryTest
{
private static Dn EXAMPLE_DN;
private static final byte[] BYTES1 = new byte[]
{ 'a', 'b' };
private static final byte[] BYTES2 = new byte[]
{ 'b' };
private static final byte[] BYTES3 = new byte[]
{ 'c' };
private static SchemaManager schemaManager;
/**
* Helper method which creates an entry with 4 attributes.
*/
private Entry createEntry()
{
try
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
Attribute attrOC = new DefaultAttribute( "objectClass", "top", "person" );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2" );
Attribute attrSN = new DefaultAttribute( "sn", "Test1", "Test2" );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2 );
entry.put( attrOC, attrCN, attrSN, attrPWD );
return entry;
}
catch ( LdapException ne )
{
// Do nothing
return null;
}
}
/**
* Serialize a ClientEntry
*/
private ByteArrayOutputStream serializeValue( Entry value ) throws IOException
{
ObjectOutputStream oOut = null;
ByteArrayOutputStream out = new ByteArrayOutputStream();
try
{
oOut = new ObjectOutputStream( out );
oOut.writeObject( value );
}
catch ( IOException ioe )
{
throw ioe;
}
finally
{
try
{
if ( oOut != null )
{
oOut.flush();
oOut.close();
}
}
catch ( IOException ioe )
{
throw ioe;
}
}
return out;
}
/**
* Deserialize a ClientEntry
*/
private Entry deserializeValue( ByteArrayOutputStream out ) throws IOException, ClassNotFoundException
{
ObjectInputStream oIn = null;
ByteArrayInputStream in = new ByteArrayInputStream( out.toByteArray() );
try
{
oIn = new ObjectInputStream( in );
Entry value = ( Entry ) oIn.readObject();
return value;
}
catch ( IOException ioe )
{
throw ioe;
}
finally
{
try
{
if ( oIn != null )
{
oIn.close();
}
}
catch ( IOException ioe )
{
throw ioe;
}
}
}
/**
* @throws java.lang.Exception
*/
@BeforeClass
public static void setUpBeforeClass() throws Exception
{
EXAMPLE_DN = new Dn( "dc=example,dc=com" );
schemaManager = new DefaultSchemaManager();
}
/**
* Test method for DefaultEntry()
*/
@Test
public void testDefaultClientEntry()
{
Entry entry = new DefaultEntry();
assertNotNull( entry );
assertEquals( Dn.EMPTY_DN, entry.getDn() );
assertEquals( 0, entry.size() );
}
/**
* Test method for DefaultEntry()
*/
@Test
public void testDefaultClientEntryLdif() throws Exception
{
Entry entry = new DefaultEntry(
"ou=example, dc=com",
"ObjectClass: top",
"ObjectClass: person",
"cn: test",
"sn: test" );
assertNotNull( entry );
assertEquals( "ou=example, dc=com", entry.getDn().toString() );
assertEquals( 3, entry.size() );
assertTrue( entry.contains( "objectClass", "top", "person" ) );
assertTrue( entry.contains( "cn", "test" ) );
assertTrue( entry.contains( "sn", "test" ) );
}
/**
* Test method for DefaultEntry( Dn )
*/
@Test
public void testDefaultClientEntryLdapDN()
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
assertNotNull( entry );
assertNotNull( entry.getDn() );
assertEquals( EXAMPLE_DN, entry.getDn() );
assertEquals( 0, entry.size() );
}
/**
* Test method for add( EntryAttribute... )
*/
@Test
public void testAddEntryAttributeArray() throws LdapException
{
Entry entry = createEntry();
assertEquals( 4, entry.size() );
assertTrue( entry.containsAttribute( "ObjectClass" ) );
assertTrue( entry.containsAttribute( "CN" ) );
assertTrue( entry.containsAttribute( " sn " ) );
assertTrue( entry.containsAttribute( "userPassword" ) );
Attribute attr = entry.get( "objectclass" );
assertEquals( 2, attr.size() );
Attribute attrCN2 = new DefaultAttribute( "cn", "test1", "test3" );
entry.add( attrCN2 );
assertEquals( 4, entry.size() );
attr = entry.get( "cn" );
assertEquals( 3, attr.size() );
assertTrue( attr.contains( "test1", "test2", "test3" ) );
// Check adding some byte[] values (they will not be transformed to Strings)
attrCN2.clear();
attrCN2.add( BYTES1, BYTES2 );
entry.add( attrCN2 );
assertEquals( 4, entry.size() );
attr = entry.get( "cn" );
assertEquals( 3, attr.size() );
assertTrue( attr.contains( "test1", "test2", "test3" ) );
assertFalse( attr.contains( "ab", "b" ) );
}
/**
* Test method for add( String, byte[]... )
*/
@Test
public void testAddStringByteArrayArray() throws LdapException
{
Entry entry = new DefaultEntry();
entry.add( "userPassword", ( byte[] ) null );
assertEquals( 1, entry.size() );
Attribute attributePWD = entry.get( "userPassword" );
assertEquals( 1, attributePWD.size() );
assertNotNull( attributePWD.get() );
assertNull( attributePWD.get().getValue() );
entry.add( "jpegPhoto", BYTES1, BYTES1, BYTES2 );
assertEquals( 2, entry.size() );
Attribute attributeJPG = entry.get( "jpegPhoto" );
assertEquals( 2, attributeJPG.size() );
assertNotNull( attributeJPG.get() );
assertTrue( attributeJPG.contains( BYTES1 ) );
assertTrue( attributeJPG.contains( BYTES2 ) );
}
/**
* Test method for add( String, String... )
*/
@Test
public void testAddStringStringArray() throws LdapException
{
Entry entry = new DefaultEntry();
entry.add( "cn", ( String ) null );
assertEquals( 1, entry.size() );
Attribute attributeCN = entry.get( "cn" );
assertEquals( 1, attributeCN.size() );
assertNotNull( attributeCN.get() );
assertNull( attributeCN.get().getValue() );
entry.add( "sn", "test", "test", "TEST" );
assertEquals( 2, entry.size() );
Attribute attributeSN = entry.get( "sn" );
assertEquals( 2, attributeSN.size() );
assertNotNull( attributeSN.get() );
assertTrue( attributeSN.contains( "test" ) );
assertTrue( attributeSN.contains( "TEST" ) );
}
/**
* Test method for add( String, Value<?>... )
*/
@Test
public void testAddStringValueArray() throws LdapException
{
Entry entry = new DefaultEntry();
Value<String> value = new StringValue( ( String ) null );
entry.add( "cn", value );
assertEquals( 1, entry.size() );
Attribute attributeCN = entry.get( "cn" );
assertEquals( 1, attributeCN.size() );
assertNotNull( attributeCN.get() );
assertNull( attributeCN.get().getValue() );
Value<String> value1 = new StringValue( "test1" );
Value<String> value2 = new StringValue( "test2" );
Value<String> value3 = new StringValue( "test1" );
entry.add( "sn", value1, value2, value3 );
assertEquals( 2, entry.size() );
Attribute attributeSN = entry.get( "sn" );
assertEquals( 2, attributeSN.size() );
assertNotNull( attributeSN.get() );
assertTrue( attributeSN.contains( value1 ) );
assertTrue( attributeSN.contains( value2 ) );
Value<byte[]> value4 = new BinaryValue( BYTES1 );
entry.add( "l", value1, value4 );
assertEquals( 3, entry.size() );
Attribute attributeL = entry.get( "l" );
assertEquals( 2, attributeL.size() );
assertNotNull( attributeL.get() );
assertTrue( attributeL.contains( value1 ) );
// The byte[] value must have been transformed to a String
assertTrue( attributeL.contains( "ab" ) );
}
/**
* Test method for clear()
*/
@Test
public void testClear() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
assertEquals( 0, entry.size() );
assertNull( entry.get( "ObjectClass" ) );
entry.clear();
assertEquals( 0, entry.size() );
assertNull( entry.get( "ObjectClass" ) );
entry.add( "ObjectClass", "top", "person" );
assertEquals( 1, entry.size() );
assertNotNull( entry.get( "ObjectClass" ) );
entry.clear();
assertEquals( 0, entry.size() );
assertNull( entry.get( "ObjectClass" ) );
}
/**
* Test method for clone()
*/
@Test
public void testClone() throws LdapException
{
Entry entry1 = new DefaultEntry();
Entry entry2 = entry1.clone();
assertEquals( entry1, entry2 );
entry2.setDn( EXAMPLE_DN );
assertEquals( Dn.EMPTY_DN, entry1.getDn() );
entry1.setDn( EXAMPLE_DN );
entry2 = entry1.clone();
assertEquals( entry1, entry2 );
entry1.add( "objectClass", "top", "person" );
entry1.add( "cn", "test1", "test2" );
entry2 = entry1.clone();
assertEquals( entry1, entry2 );
entry1.add( "cn", "test3" );
assertEquals( 2, entry2.get( "cn" ).size() );
assertFalse( entry2.contains( "cn", "test3" ) );
entry1.add( "sn", ( String ) null );
assertFalse( entry2.containsAttribute( "sn" ) );
}
/**
* Test method for contains( EntryAttribute... )
*/
@Test
public void testContainsEntryAttributeArray() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
Attribute attrOC = new DefaultAttribute( "objectClass", "top", "person" );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2" );
Attribute attrSN = new DefaultAttribute( "sn", "Test1", "Test2" );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2 );
assertFalse( entry.contains( attrOC, attrCN ) );
entry.add( attrOC, attrCN );
assertTrue( entry.contains( attrOC, attrCN ) );
assertFalse( entry.contains( attrOC, attrCN, attrSN ) );
entry.add( attrSN, attrPWD );
assertTrue( entry.contains( attrSN, attrPWD ) );
}
/**
* Test method for contains( String, byte[]... )
*/
@Test
public void testContainsStringByteArray() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
assertFalse( entry.containsAttribute( "objectClass" ) );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, ( byte[] ) null, BYTES2 );
entry.add( attrPWD );
assertTrue( entry.contains( " userPASSWORD ", BYTES1, BYTES2 ) );
assertTrue( entry.contains( " userPASSWORD ", ( byte[] ) null ) );
// We can search for byte[] using Strings. the strings will be converted to byte[]
assertTrue( entry.contains( " userPASSWORD ", "ab", "b" ) );
assertFalse( entry.contains( " userPASSWORD ", "ab", "b", "d" ) );
}
/**
* Test method for contains( String, String... )
*/
@Test
public void testContainsStringStringArray() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
assertFalse( entry.containsAttribute( "objectClass" ) );
Attribute attrOC = new DefaultAttribute( "objectClass", "top", "person" );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2" );
Attribute attrSN = new DefaultAttribute( "sn", "Test1", "Test2", ( String ) null );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2 );
entry.add( attrOC, attrCN, attrSN, attrPWD );
assertTrue( entry.contains( "OBJECTCLASS", "top", "person" ) );
assertTrue( entry.contains( " cn ", "test1", "test2" ) );
assertTrue( entry.contains( "Sn", "Test1", "Test2", ( String ) null ) );
assertTrue( entry.contains( " userPASSWORD ", "ab", "b" ) );
assertFalse( entry.contains( "OBJECTCLASS", "PERSON" ) );
assertFalse( entry.contains( " cn ", "test1", "test3" ) );
assertFalse( entry.contains( "Sn", "Test" ) );
assertFalse( entry.contains( " userPASSWORD ", ( String ) null ) );
}
/**
* Test method for contains( Sring, Value<?>... )
*/
@Test
public void testContainsStringValueArray() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
assertFalse( entry.containsAttribute( "objectClass" ) );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2", ( String ) null );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2, ( byte[] ) null );
entry.add( attrCN, attrPWD );
Value<String> strValue1 = new StringValue( "test1" );
Value<String> strValue2 = new StringValue( "test2" );
Value<String> strValue3 = new StringValue( "test3" );
Value<String> strNullValue = new StringValue( ( String ) null );
Value<byte[]> binValue1 = new BinaryValue( BYTES1 );
Value<byte[]> binValue2 = new BinaryValue( BYTES2 );
Value<byte[]> binValue3 = new BinaryValue( BYTES3 );
Value<byte[]> binNullValue = new BinaryValue( ( byte[] ) null );
assertTrue( entry.contains( "CN", strValue1, strValue2, strNullValue ) );
assertTrue( entry.contains( "userpassword", binValue1, binValue2, binNullValue ) );
assertFalse( entry.contains( "cn", strValue3 ) );
assertFalse( entry.contains( "UserPassword", binValue3 ) );
}
/**
* Test method for containsAttribute( String )
*/
@Test
public void testContainsAttribute() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
assertFalse( entry.containsAttribute( "objectClass" ) );
Attribute attrOC = new DefaultAttribute( "objectClass", "top", "person" );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2" );
Attribute attrSN = new DefaultAttribute( "sn", "Test1", "Test2" );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2 );
entry.add( attrOC, attrCN, attrSN, attrPWD );
assertTrue( entry.containsAttribute( "OBJECTCLASS" ) );
assertTrue( entry.containsAttribute( " cn " ) );
assertTrue( entry.containsAttribute( "Sn" ) );
assertTrue( entry.containsAttribute( " userPASSWORD " ) );
entry.clear();
assertFalse( entry.containsAttribute( "OBJECTCLASS" ) );
assertFalse( entry.containsAttribute( " cn " ) );
assertFalse( entry.containsAttribute( "Sn" ) );
assertFalse( entry.containsAttribute( " userPASSWORD " ) );
}
/**
* Test method for equals()
*/
@Test
public void testEqualsObject() throws LdapException
{
Entry entry1 = new DefaultEntry();
Entry entry2 = new DefaultEntry();
assertEquals( entry1, entry2 );
entry1.setDn( EXAMPLE_DN );
assertNotSame( entry1, entry2 );
entry2.setDn( EXAMPLE_DN );
assertEquals( entry1, entry2 );
Attribute attrOC = new DefaultAttribute( "objectClass", "top", "person" );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2" );
Attribute attrSN = new DefaultAttribute( "sn", "Test1", "Test2" );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2 );
entry1.put( attrOC, attrCN, attrSN, attrPWD );
entry2.put( attrOC, attrCN, attrSN );
assertNotSame( entry1, entry2 );
entry2.put( attrPWD );
assertEquals( entry1, entry2 );
Attribute attrL1 = new DefaultAttribute( "l", "Paris", "New-York" );
Attribute attrL2 = new DefaultAttribute( "l", "Paris", "Tokyo" );
entry1.put( attrL1 );
entry2.put( attrL1 );
assertEquals( entry1, entry2 );
entry1.add( "l", "London" );
assertNotSame( entry1, entry2 );
entry2.add( attrL2 );
assertNotSame( entry1, entry2 );
entry1.clear();
entry2.clear();
assertEquals( entry1, entry2 );
}
/**
* Test method for get( String )
*/
@Test
public void testGet() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
assertNull( entry.get( "objectClass" ) );
Attribute attrOC = new DefaultAttribute( "objectClass", "top", "person" );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2" );
Attribute attrSN = new DefaultAttribute( "sn", "Test1", "Test2" );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2 );
entry.add( attrOC, attrCN, attrSN, attrPWD );
assertNotNull( entry.get( " CN " ) );
Attribute attribute = entry.get( "cN" );
assertEquals( attribute, attrCN );
assertNull( entry.get( ( String ) null ) );
assertNull( entry.get( " " ) );
assertNull( entry.get( "l" ) );
}
/**
* Test method for getDN()
*/
@Test
public void testGetDn() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
assertEquals( EXAMPLE_DN, entry.getDn() );
Dn testDn = new Dn( "cn=test" );
entry.setDn( testDn );
assertEquals( testDn, entry.getDn() );
}
/**
* Test method for hashcode()
*/
@Test
public void testHashCode() throws LdapException, LdapException
{
Entry entry1 = new DefaultEntry( EXAMPLE_DN );
Entry entry2 = new DefaultEntry( EXAMPLE_DN );
assertEquals( entry1.hashCode(), entry2.hashCode() );
entry2.setDn( new Dn( "ou=system,dc=com" ) );
assertNotSame( entry1.hashCode(), entry2.hashCode() );
entry2.setDn( EXAMPLE_DN );
assertEquals( entry1.hashCode(), entry2.hashCode() );
Attribute attrOC = new DefaultAttribute( "objectClass", "top", "person" );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2" );
Attribute attrSN = new DefaultAttribute( "sn", "Test1", "Test2" );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2 );
entry1.add( attrOC, attrCN, attrSN, attrPWD );
entry2.add( attrOC, attrCN, attrSN, attrPWD );
assertEquals( entry1.hashCode(), entry2.hashCode() );
Entry entry3 = new DefaultEntry( EXAMPLE_DN );
entry3.add( attrOC, attrSN, attrCN, attrPWD );
assertEquals( entry1.hashCode(), entry3.hashCode() );
}
/**
* Test method for hasObjectClass( String )
*/
@Test
public void testHasObjectClass() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
assertFalse( entry.containsAttribute( "objectClass" ) );
assertFalse( entry.hasObjectClass( "top" ) );
entry.add( new DefaultAttribute( "objectClass", "top", "person" ) );
assertTrue( entry.hasObjectClass( "top" ) );
assertTrue( entry.hasObjectClass( "person" ) );
assertFalse( entry.hasObjectClass( "inetorgperson" ) );
assertFalse( entry.hasObjectClass( ( String ) null ) );
assertFalse( entry.hasObjectClass( "" ) );
}
/**
* Test method for Iterator()
*/
@Test
public void testIterator() throws LdapException
{
Entry entry = createEntry();
Iterator<Attribute> iterator = entry.iterator();
assertTrue( iterator.hasNext() );
Set<String> expectedIds = new HashSet<String>();
expectedIds.add( "objectclass" );
expectedIds.add( "cn" );
expectedIds.add( "sn" );
expectedIds.add( "userpassword" );
while ( iterator.hasNext() )
{
Attribute attribute = iterator.next();
String id = attribute.getId();
assertTrue( expectedIds.contains( id ) );
expectedIds.remove( id );
}
assertEquals( 0, expectedIds.size() );
}
/**
* Test method for put( EntryAttribute... )
*/
@Test
public void testPutEntryAttributeArray() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
Attribute attrOC = new DefaultAttribute( "objectClass", "top", "person" );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2" );
Attribute attrSN = new DefaultAttribute( "sn", "Test1", "Test2" );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2 );
List<Attribute> removed = entry.put( attrOC, attrCN, attrSN, attrPWD );
assertEquals( 4, entry.size() );
assertEquals( 0, removed.size() );
assertTrue( entry.containsAttribute( "ObjectClass" ) );
assertTrue( entry.containsAttribute( "CN" ) );
assertTrue( entry.containsAttribute( " sn " ) );
assertTrue( entry.containsAttribute( "userPassword" ) );
Attribute attrCN2 = new DefaultAttribute( "cn", "test3", "test4" );
removed = entry.put( attrCN2 );
assertEquals( 4, entry.size() );
assertEquals( 1, removed.size() );
assertTrue( entry.containsAttribute( "CN" ) );
assertTrue( entry.contains( "cn", "test3", "test4" ) );
}
/**
* Test method for put( String, byte[]... )
*/
@Test
public void testPutStringByteArrayArray()
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
try
{
entry.put( ( String ) null, BYTES1 );
fail();
}
catch ( IllegalArgumentException iae )
{
assertTrue( true );
}
try
{
entry.put( " ", BYTES1 );
fail();
}
catch ( IllegalArgumentException iae )
{
assertTrue( true );
}
entry.put( "userPassword", ( byte[] ) null );
assertEquals( 1, entry.size() );
assertNotNull( entry.get( "userPassword" ) );
assertEquals( 1, entry.get( "userPassword" ).size() );
assertNull( entry.get( "userPassword" ).get().getValue() );
entry.put( "jpegPhoto", BYTES1, BYTES2, BYTES1 );
assertEquals( 2, entry.size() );
assertNotNull( entry.get( "jpegPhoto" ) );
assertEquals( 2, entry.get( "JPEGPhoto" ).size() );
Attribute attribute = entry.get( "jpegPhoto" );
assertTrue( attribute.contains( BYTES1 ) );
assertTrue( attribute.contains( BYTES2 ) );
assertEquals( "jpegphoto", attribute.getId() );
assertEquals( "jpegPhoto", attribute.getUpId() );
}
/**
* Test method for put( String, String... )
*/
@Test
public void testPutStringStringArray()
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
try
{
entry.put( ( String ) null, "a" );
fail();
}
catch ( IllegalArgumentException iae )
{
assertTrue( true );
}
try
{
entry.put( " ", "a" );
fail();
}
catch ( IllegalArgumentException iae )
{
assertTrue( true );
}
entry.put( "sn", ( String ) null );
assertEquals( 1, entry.size() );
assertNotNull( "sn", entry.get( "sn" ) );
assertEquals( 1, entry.get( "sn" ).size() );
assertNull( entry.get( "sn" ).get().getValue() );
entry.put( "ObjectClass", "top", "person", "top" );
assertEquals( 2, entry.size() );
assertNotNull( "objectclass", entry.get( "sn" ) );
assertEquals( 2, entry.get( "OBJECTCLASS" ).size() );
Attribute attribute = entry.get( "objectClass" );
assertTrue( attribute.contains( "top" ) );
assertTrue( attribute.contains( "person" ) );
assertEquals( "objectclass", attribute.getId() );
assertEquals( "ObjectClass", attribute.getUpId() );
}
/**
* Test method for pu( String, Value<?>... )
*/
@Test
public void testPutStringValueArray()
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
Value<String> strValueTop = new StringValue( "top" );
Value<String> strValuePerson = new StringValue( "person" );
Value<String> strValueTop2 = new StringValue( "top" );
Value<String> strNullValue = new StringValue( ( String ) null );
Value<byte[]> binValue1 = new BinaryValue( BYTES1 );
Value<byte[]> binValue2 = new BinaryValue( BYTES2 );
Value<byte[]> binValue3 = new BinaryValue( BYTES1 );
Value<byte[]> binNullValue = new BinaryValue( ( byte[] ) null );
try
{
entry.put( ( String ) null, strValueTop );
fail();
}
catch ( IllegalArgumentException iae )
{
assertTrue( true );
}
try
{
entry.put( " ", strValueTop );
fail();
}
catch ( IllegalArgumentException iae )
{
assertTrue( true );
}
entry.put( "sn", strNullValue );
assertEquals( 1, entry.size() );
assertNotNull( "sn", entry.get( "sn" ) );
assertEquals( 1, entry.get( "sn" ).size() );
assertNull( entry.get( "sn" ).get().getValue() );
entry.clear();
entry.put( "ObjectClass", strValueTop, strValuePerson, strValueTop2, strNullValue );
assertEquals( 1, entry.size() );
assertNotNull( "objectclass", entry.get( "objectclass" ) );
assertEquals( 3, entry.get( "OBJECTCLASS" ).size() );
Attribute attribute = entry.get( "objectClass" );
assertTrue( attribute.contains( "top" ) );
assertTrue( attribute.contains( "person" ) );
assertTrue( attribute.contains( ( String ) null ) );
assertEquals( "objectclass", attribute.getId() );
assertEquals( "ObjectClass", attribute.getUpId() );
entry.clear();
entry.put( "userpassword", strNullValue );
assertEquals( 1, entry.size() );
assertNotNull( "userpassword", entry.get( "userpassword" ) );
assertEquals( 1, entry.get( "userpassword" ).size() );
assertNull( entry.get( "userpassword" ).get().getValue() );
entry.clear();
entry.put( "userPassword", binValue1, binValue2, binValue3, binNullValue );
assertEquals( 1, entry.size() );
assertNotNull( "userpassword", entry.get( "userpassword" ) );
assertEquals( 3, entry.get( "userpassword" ).size() );
attribute = entry.get( "userpassword" );
assertTrue( attribute.contains( BYTES1 ) );
assertTrue( attribute.contains( BYTES2 ) );
assertTrue( attribute.contains( ( byte[] ) null ) );
assertEquals( "userpassword", attribute.getId() );
assertEquals( "userPassword", attribute.getUpId() );
}
/**
* Test method for removeAttributes( String... )
*/
@Test
public void testRemoveAttributesStringArray() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
Attribute attrOC = new DefaultAttribute( "objectClass", "top", "person" );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2" );
Attribute attrSN = new DefaultAttribute( "sn", "Test1", "Test2" );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2 );
entry.put( attrOC, attrCN, attrSN, attrPWD );
entry.removeAttributes( "CN", "SN" );
assertFalse( entry.containsAttribute( "cn", "sn" ) );
assertTrue( entry.containsAttribute( "objectclass", "userpassword" ) );
List<Attribute> removed = entry.removeAttributes( "badId" );
assertNull( removed );
removed = entry.removeAttributes( ( String ) null );
assertNull( removed );
}
/**
* Test method for remove( EntryAttribute... )
*/
@Test
public void testRemoveEntryAttributeArray() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
Attribute attrOC = new DefaultAttribute( "objectClass", "top", "person" );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2" );
Attribute attrSN = new DefaultAttribute( "sn", "Test1", "Test2" );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2 );
entry.put( attrOC, attrCN, attrSN, attrPWD );
List<Attribute> removed = entry.remove( attrSN, attrPWD );
assertEquals( 2, removed.size() );
assertEquals( 2, entry.size() );
assertTrue( removed.contains( attrSN ) );
assertTrue( removed.contains( attrPWD ) );
assertTrue( entry.contains( "objectClass", "top", "person" ) );
assertTrue( entry.contains( "cn", "test1", "test2" ) );
assertFalse( entry.containsAttribute( "sn" ) );
assertFalse( entry.containsAttribute( "userPassword" ) );
removed = entry.remove( attrSN, attrPWD );
assertEquals( 0, removed.size() );
}
/**
* Test method for remove(String, byte[]... )
*/
@Test
public void testRemoveStringByteArrayArray() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, ( byte[] ) null, BYTES2 );
entry.put( attrPWD );
assertTrue( entry.remove( "userPassword", ( byte[] ) null ) );
assertTrue( entry.remove( "userPassword", BYTES1, BYTES2 ) );
assertFalse( entry.containsAttribute( "userPassword" ) );
entry.add( "userPassword", BYTES1, ( byte[] ) null, BYTES2 );
assertTrue( entry.remove( "userPassword", ( byte[] ) null ) );
assertEquals( 2, entry.get( "userPassword" ).size() );
assertTrue( entry.remove( "userPassword", BYTES1, BYTES3 ) );
assertEquals( 1, entry.get( "userPassword" ).size() );
assertTrue( Arrays.equals( BYTES2, entry.get( "userPassword" ).getBytes() ) );
assertFalse( entry.remove( "userPassword", BYTES3 ) );
assertFalse( entry.remove( "void", "whatever" ) );
}
/**
* Test method for remove( String, String... )
*/
@Test
public void testRemoveStringStringArray() throws LdapException
{
Entry entry = createEntry();
assertTrue( entry.remove( "cn", "test1" ) );
assertTrue( entry.remove( "cn", "test2" ) );
assertFalse( entry.containsAttribute( "cn" ) );
entry.add( "cn", "test1", ( String ) null, "test2" );
assertTrue( entry.remove( "cn", ( String ) null ) );
assertEquals( 2, entry.get( "cn" ).size() );
assertTrue( entry.remove( "cn", "test1", "test3" ) );
assertEquals( 1, entry.get( "cn" ).size() );
assertEquals( "test2", entry.get( "cn" ).get().getString() );
assertFalse( entry.remove( "cn", "test3" ) );
assertFalse( entry.remove( "void", "whatever" ) );
}
/**
* Test method for remove(String, Value<?>... )
*/
@Test
public void testRemoveStringValueArray() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
Attribute attrCN = new DefaultAttribute( "cn", "test1", "test2", ( String ) null );
Attribute attrPWD = new DefaultAttribute( "userPassword", BYTES1, BYTES2, ( byte[] ) null );
entry.add( attrCN, attrPWD );
Value<String> strValue1 = new StringValue( "test1" );
Value<String> strValue2 = new StringValue( "test2" );
Value<String> strValue3 = new StringValue( "test3" );
Value<String> strNullValue = new StringValue( ( String ) null );
Value<byte[]> binValue1 = new BinaryValue( BYTES1 );
Value<byte[]> binValue2 = new BinaryValue( BYTES2 );
Value<byte[]> binValue3 = new BinaryValue( BYTES3 );
Value<byte[]> binNullValue = new BinaryValue( ( byte[] ) null );
assertTrue( entry.remove( "cn", strValue1, strNullValue ) );
assertTrue( entry.contains( "cn", strValue2 ) );
assertFalse( entry.remove( "cn", strValue3 ) );
assertTrue( entry.remove( "cn", strValue2 ) );
assertFalse( entry.containsAttribute( "cn" ) );
entry.add( attrCN, attrPWD );
assertTrue( entry.remove( "userpassword", binValue1, binNullValue ) );
assertTrue( entry.contains( "userpassword", binValue2 ) );
assertFalse( entry.remove( "userpassword", binValue3 ) );
assertTrue( entry.remove( "userpassword", binValue2 ) );
assertFalse( entry.containsAttribute( "userpassword" ) );
}
/**
* Test method for setDN( Dn )
*/
@Test
public void testSetDn()
{
Entry entry = new DefaultEntry();
assertEquals( Dn.EMPTY_DN, entry.getDn() );
entry.setDn( EXAMPLE_DN );
assertEquals( EXAMPLE_DN, entry.getDn() );
}
/**
* Test method for size()
*/
@Test
public void testSize() throws LdapException
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
assertEquals( 0, entry.size() );
entry.add( "ObjectClass", "top", "person" );
entry.add( "cn", "test" );
entry.add( "sn", "Test" );
assertEquals( 3, entry.size() );
entry.clear();
assertEquals( 0, entry.size() );
}
/**
* Test method for for {@link org.apache.directory.shared.ldap.model.entry.DefaultEntry#toString()}.
*/
@Test
public void testToString()
{
Entry entry = new DefaultEntry( EXAMPLE_DN );
assertEquals( "Entry\n dn: dc=example,dc=com\n", entry.toString() );
Value<String> strValueTop = new StringValue( "top" );
Value<String> strValuePerson = new StringValue( "person" );
Value<String> strNullValue = new StringValue( ( String ) null );
Value<byte[]> binValue1 = new BinaryValue( BYTES1 );
Value<byte[]> binValue2 = new BinaryValue( BYTES2 );
Value<byte[]> binNullValue = new BinaryValue( ( byte[] ) null );
entry.put( "ObjectClass", strValueTop, strValuePerson, strNullValue );
entry.put( "UserPassword", binValue1, binValue2, binNullValue );
String expected =
"Entry\n" +
" dn: dc=example,dc=com\n" +
" ObjectClass: top\n" +
" ObjectClass: person\n" +
" ObjectClass: ''\n" +
" UserPassword: '0x61 0x62 '\n" +
" UserPassword: '0x62 '\n" +
" UserPassword: ''\n";
assertEquals( expected, entry.toString() );
}
/**
* Test the serialization of a complete entry
*/
@Test
public void testSerializeCompleteEntry() throws LdapException, IOException, ClassNotFoundException
{
Dn dn = new Dn( "ou=system" );
dn.apply( schemaManager );
byte[] password = Strings.getBytesUtf8( "secret" );
Entry entry = new DefaultEntry( dn );
entry.add( "ObjectClass", "top", "person" );
entry.add( "cn", "test1" );
entry.add( "userPassword", password );
Entry entrySer = deserializeValue( serializeValue( entry ) );
assertEquals( entry, entrySer );
}
/**
* Test the serialization of an entry with no Dn
*/
@Test
public void testSerializeEntryWithNoDN() throws LdapException, IOException, ClassNotFoundException
{
byte[] password = Strings.getBytesUtf8( "secret" );
Entry entry = new DefaultEntry();
entry.add( "ObjectClass", "top", "person" );
entry.add( "cn", "test1" );
entry.add( "userPassword", password );
Entry entrySer = deserializeValue( serializeValue( entry ) );
assertEquals( entry, entrySer );
}
/**
* Test the serialization of an entry with no attribute and no Dn
*/
@Test
public void testSerializeEntryWithNoDNNoAttribute() throws LdapException, IOException, ClassNotFoundException
{
Entry entry = new DefaultEntry();
Entry entrySer = deserializeValue( serializeValue( entry ) );
assertEquals( entry, entrySer );
}
/**
* Test the serialization of an entry with no attribute
*/
@Test
public void testSerializeEntryWithNoAttribute() throws LdapException, IOException, ClassNotFoundException
{
Dn dn = new Dn( "ou=system" );
dn.apply( schemaManager );
Entry entry = new DefaultEntry( dn );
Entry entrySer = deserializeValue( serializeValue( entry ) );
assertEquals( entry, entrySer );
}
/**
* Test method for userCertificate;binary AT
*/
@Test
public void testUserCertificateBinary() throws LdapException
{
Entry entry = new DefaultEntry( schemaManager );
entry.add( "objectClass", "top", "person", "inetorgPerson" );
entry.add( "cn", "test1", "test2" );
entry.add( "sn", "Test1", "Test2" );
entry.add( "userPassword", BYTES1, BYTES2 );
entry.add( "userCertificate;binary", Strings.getBytesUtf8( "secret" ) );
assertTrue( entry.containsAttribute( "userCertificate;binary" ) );
assertTrue( entry.containsAttribute( "userCertificate" ) );
entry.removeAttributes( "userCertificate;binary" );
assertFalse( entry.containsAttribute( "userCertificate;binary" ) );
assertFalse( entry.containsAttribute( "userCertificate" ) );
entry.add( "userCertificate", Strings.getBytesUtf8( "secret" ) );
assertTrue( entry.containsAttribute( "userCertificate;binary" ) );
assertTrue( entry.containsAttribute( "userCertificate" ) );
}
}