/*
* 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.model.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 java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import org.apache.directory.api.ldap.model.entry.BinaryValue;
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.schema.AttributeType;
import org.apache.directory.api.ldap.model.schema.LdapSyntax;
import org.apache.directory.api.ldap.model.schema.MutableAttributeType;
import org.apache.directory.api.ldap.model.schema.MutableMatchingRule;
import org.apache.directory.api.ldap.model.schema.Normalizer;
import org.apache.directory.api.ldap.model.schema.SyntaxChecker;
import org.apache.directory.api.ldap.model.schema.comparators.ByteArrayComparator;
import org.apache.directory.api.ldap.model.schema.syntaxCheckers.OctetStringSyntaxChecker;
import org.apache.directory.api.util.StringConstants;
import org.apache.directory.api.util.Strings;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import com.mycila.junit.concurrent.Concurrency;
import com.mycila.junit.concurrent.ConcurrentJunitRunner;
/**
*
* Test the BinaryValue class
*
* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
*/
@RunWith(ConcurrentJunitRunner.class)
@Concurrency()
public class BinaryValueTest
{
private static final byte[] BYTES1 = new byte[]
{ 0x01, 0x02, 0x03, 0x04 };
private static final byte[] BYTES2 = new byte[]
{ ( byte ) 0x81, ( byte ) 0x82, ( byte ) 0x83, ( byte ) 0x84 };
private static final byte[] INVALID_BYTES = new byte[]
{ 0x01, 0x02, 0x03, 0x04, 0x05 };
private static final byte[] BYTES_MOD = new byte[]
{ 0x11, 0x02, 0x03, 0x04 };
private LdapSyntax s;
private MutableAttributeType at;
private MutableMatchingRule mr;
/**
* Initialize an AttributeType and the associated MatchingRule
* and Syntax
*/
@Before
public void initAT()
{
s = EntryUtils.syntaxFactory( "1.1.1.1", false );
s.setSyntaxChecker( new OctetStringSyntaxChecker() );
mr = EntryUtils.matchingRuleFactory( "1.1.2.1" );
mr.setSyntax( s );
mr.setLdapComparator( new ByteArrayComparator( "1.1.1" ) );
mr.setNormalizer( new Normalizer( "1.1.1" )
{
public Value<?> normalize( Value<?> value ) throws LdapException
{
if ( !value.isHumanReadable() )
{
byte[] val = value.getBytes();
// each byte will be changed to be > 0, and spaces will be trimmed
byte[] newVal = new byte[val.length];
int i = 0;
for ( byte b : val )
{
newVal[i++] = ( byte ) ( b & 0x007F );
}
return new BinaryValue( Strings.trim( newVal ) );
}
throw new IllegalStateException( "expected byte[] to normalize" );
}
public String normalize( String value ) throws LdapException
{
throw new IllegalStateException( "expected byte[] to normalize" );
}
} );
at = new MutableAttributeType( "1.1.3.1" );
at.setEquality( mr );
at.setOrdering( mr );
at.setSubstring( mr );
at.setSyntax( s );
}
/**
* A binary normalizer which set the normalized value to a empty byte array
*/
private static final Normalizer BINARY_NORMALIZER_EMPTY = new Normalizer( "1.1.1" )
{
public Value<?> normalize( Value<?> value ) throws LdapException
{
if ( !value.isHumanReadable() )
{
return new BinaryValue( StringConstants.EMPTY_BYTES );
}
throw new IllegalStateException( "expected byte[] to normalize" );
}
public String normalize( String value ) throws LdapException
{
throw new IllegalStateException( "expected byte[] to normalize" );
}
};
private static final SyntaxChecker BINARY_CHECKER = new SyntaxChecker( "1.1.1" )
{
public boolean isValidSyntax( Object value )
{
if ( value == null )
{
return true;
}
return ( ( byte[] ) value ).length < 5;
}
};
/**
* Serialize a BinaryValue
*/
private ByteArrayOutputStream serializeValue( BinaryValue 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 BinaryValue
*/
private BinaryValue deserializeValue( AttributeType at, ByteArrayOutputStream out ) throws IOException,
ClassNotFoundException
{
ObjectInputStream oIn = null;
ByteArrayInputStream in = new ByteArrayInputStream( out.toByteArray() );
try
{
oIn = new ObjectInputStream( in );
BinaryValue value = new BinaryValue( at );
value.readExternal( oIn );
return value;
}
catch ( IOException ioe )
{
throw ioe;
}
finally
{
try
{
if ( oIn != null )
{
oIn.close();
}
}
catch ( IOException ioe )
{
throw ioe;
}
}
}
@Test
public void testHashCode()
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertEquals( 0, bv.hashCode() );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
int h = Arrays.hashCode( StringConstants.EMPTY_BYTES );
assertEquals( h, bv.hashCode() );
h = Arrays.hashCode( BYTES1 );
bv = new BinaryValue( BYTES1 );
assertEquals( h, bv.hashCode() );
}
@Test
public void testBinaryValueNull() throws LdapException
{
BinaryValue cbv = new BinaryValue( ( byte[] ) null );
assertNull( cbv.getValue() );
assertFalse( cbv.isSchemaAware() );
assertTrue( cbv.isValid( BINARY_CHECKER ) );
assertTrue( cbv.isNull() );
assertNull( cbv.getNormValue() );
}
@Test
public void testBinaryValueEmpty() throws LdapException
{
BinaryValue cbv = new BinaryValue( StringConstants.EMPTY_BYTES );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, cbv.getBytes() ) );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, cbv.getValue() ) );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, cbv.getReference() ) );
assertFalse( cbv.isSchemaAware() );
assertTrue( cbv.isValid( BINARY_CHECKER ) );
assertFalse( cbv.isNull() );
assertNotNull( cbv.getNormValue() );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, cbv.getNormValue() ) );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, cbv.getNormReference() ) );
}
@Test
public void testBinaryValue() throws LdapException
{
BinaryValue cbv = new BinaryValue( BYTES1 );
assertTrue( Arrays.equals( BYTES1, cbv.getBytes() ) );
assertTrue( Arrays.equals( BYTES1, cbv.getValue() ) );
assertTrue( Arrays.equals( BYTES1, cbv.getReference() ) );
assertFalse( cbv.isSchemaAware() );
assertTrue( cbv.isValid( BINARY_CHECKER ) );
assertFalse( cbv.isNull() );
assertNotNull( cbv.getNormValue() );
assertTrue( Arrays.equals( BYTES1, cbv.getNormValue() ) );
}
@Test
public void testSetByteArray() throws LdapException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
bv = new BinaryValue( BYTES1 );
assertTrue( Arrays.equals( BYTES1, bv.getBytes() ) );
assertTrue( Arrays.equals( BYTES1, bv.getValue() ) );
assertTrue( Arrays.equals( BYTES1, bv.getReference() ) );
assertFalse( bv.isSchemaAware() );
assertTrue( bv.isValid( BINARY_CHECKER ) );
assertFalse( bv.isNull() );
assertNotNull( bv.getNormValue() );
assertTrue( Arrays.equals( BYTES1, bv.getNormValue() ) );
}
@Test
public void testGetNormalizedValueCopy() throws LdapException
{
BinaryValue cbv = new BinaryValue( BYTES2 );
assertTrue( Arrays.equals( BYTES2, cbv.getBytes() ) );
assertTrue( Arrays.equals( BYTES2, cbv.getValue() ) );
assertTrue( Arrays.equals( BYTES2, cbv.getReference() ) );
assertFalse( cbv.isSchemaAware() );
assertTrue( cbv.isValid( BINARY_CHECKER ) );
assertFalse( cbv.isNull() );
assertNotNull( cbv.getNormValue() );
assertTrue( Arrays.equals( BYTES2, cbv.getNormValue() ) );
cbv.apply( at );
byte[] copy = cbv.getNormValue();
assertTrue( Arrays.equals( BYTES1, copy ) );
cbv.getNormReference()[0] = 0x11;
assertTrue( Arrays.equals( BYTES1, copy ) );
}
@Test
public void testNormalizeNormalizer() throws LdapException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
bv.apply( at );
assertTrue( bv.isSchemaAware() );
assertEquals( null, bv.getNormValue() );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
bv.apply( at );
assertTrue( bv.isSchemaAware() );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, bv.getBytes() ) );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, bv.getNormValue() ) );
bv = new BinaryValue( BYTES1 );
bv.apply( at );
assertTrue( bv.isSchemaAware() );
assertTrue( Arrays.equals( BYTES1, bv.getBytes() ) );
assertTrue( Arrays.equals( BYTES1, bv.getNormValue() ) );
bv = new BinaryValue( BYTES2 );
bv.apply( at );
assertTrue( bv.isSchemaAware() );
assertTrue( Arrays.equals( BYTES2, bv.getBytes() ) );
assertTrue( Arrays.equals( BYTES1, bv.getNormValue() ) );
}
@Test
public void testCompareToValueOfbyte() throws LdapException
{
BinaryValue bv1 = new BinaryValue( ( byte[] ) null );
BinaryValue bv2 = new BinaryValue( ( byte[] ) null );
assertEquals( 0, bv1.compareTo( bv2 ) );
bv1 = new BinaryValue( BYTES1 );
assertEquals( 1, bv1.compareTo( bv2 ) );
bv2 = new BinaryValue( BYTES2 );
assertEquals( 1, bv1.compareTo( bv2 ) );
bv2.apply( at );
assertEquals( 0, bv1.compareTo( bv2 ) );
bv1 = new BinaryValue( BYTES2 );
assertEquals( -1, bv1.compareTo( bv2 ) );
}
@Test
public void testEquals() throws LdapException
{
BinaryValue bv1 = new BinaryValue( ( byte[] ) null );
BinaryValue bv2 = new BinaryValue( ( byte[] ) null );
assertEquals( bv1, bv2 );
bv1 = new BinaryValue( BYTES1 );
assertNotSame( bv1, bv2 );
bv2 = new BinaryValue( BYTES2 );
assertNotSame( bv1, bv2 );
bv2.apply( at );
assertEquals( bv1, bv2 );
bv1 = new BinaryValue( BYTES2 );
assertNotSame( bv1, bv2 );
}
@Test
public void testClone()
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
BinaryValue copy = bv.clone();
assertEquals( bv, copy );
bv = new BinaryValue( BYTES1 );
assertNotSame( bv, copy );
copy = bv.clone();
assertEquals( bv, copy );
bv.getReference()[0] = 0x11;
assertTrue( Arrays.equals( BYTES_MOD, bv.getBytes() ) );
assertTrue( Arrays.equals( BYTES1, copy.getBytes() ) );
}
@Test
public void testGetCopy()
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertNull( bv.getValue() );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
assertNotNull( bv.getValue() );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, bv.getValue() ) );
bv = new BinaryValue( BYTES1 );
byte[] copy = bv.getValue();
assertTrue( Arrays.equals( BYTES1, copy ) );
bv.getReference()[0] = 0x11;
assertTrue( Arrays.equals( BYTES1, copy ) );
assertTrue( Arrays.equals( BYTES_MOD, bv.getBytes() ) );
}
@Test
public void testCompareTo() throws LdapException
{
BinaryValue bv1 = new BinaryValue( ( byte[] ) null );
BinaryValue bv2 = new BinaryValue( ( byte[] ) null );
assertEquals( 0, bv1.compareTo( bv2 ) );
bv1 = new BinaryValue( BYTES1 );
assertEquals( 1, bv1.compareTo( bv2 ) );
assertEquals( -1, bv2.compareTo( bv1 ) );
bv2 = new BinaryValue( BYTES1 );
assertEquals( 0, bv1.compareTo( bv2 ) );
// Now check that the equals method works on normalized values.
bv1 = new BinaryValue( BYTES2 );
bv2 = new BinaryValue( BYTES1 );
bv1.apply( at );
assertEquals( 0, bv1.compareTo( bv2 ) );
bv1 = new BinaryValue( BYTES1 );
bv2 = new BinaryValue( BYTES2 );
assertEquals( 1, bv1.compareTo( bv2 ) );
bv1 = new BinaryValue( BYTES2 );
bv2 = new BinaryValue( BYTES1 );
assertEquals( -1, bv1.compareTo( bv2 ) );
}
@Test
public void testToString()
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertEquals( "null", bv.toString() );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
assertEquals( "''", bv.toString() );
bv = new BinaryValue( BYTES1 );
assertEquals( "'0x01 0x02 0x03 0x04 '", bv.toString() );
}
@Test
public void testGetReference()
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertNull( bv.getReference() );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
assertNotNull( bv.getReference() );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, bv.getReference() ) );
bv = new BinaryValue( BYTES1 );
byte[] reference = bv.getReference();
assertTrue( Arrays.equals( BYTES1, reference ) );
bv.getReference()[0] = 0x11;
assertTrue( Arrays.equals( BYTES_MOD, reference ) );
assertTrue( Arrays.equals( BYTES_MOD, bv.getBytes() ) );
}
@Test
public void testGet()
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertNull( bv.getValue() );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
assertNotNull( bv.getValue() );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, bv.getBytes() ) );
bv = new BinaryValue( BYTES1 );
byte[] get = bv.getBytes();
assertTrue( Arrays.equals( BYTES1, get ) );
bv.getReference()[0] = 0x11;
assertTrue( Arrays.equals( BYTES1, get ) );
assertTrue( Arrays.equals( BYTES_MOD, bv.getBytes() ) );
}
@Test
public void testGetNormalizedValue() throws LdapException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertFalse( bv.isSchemaAware() );
bv.apply( at );
byte[] value = bv.getNormValue();
assertNull( value );
assertTrue( bv.isSchemaAware() );
bv = new BinaryValue( BYTES2 );
bv.apply( at );
value = bv.getNormValue();
assertTrue( Arrays.equals( BYTES1, value ) );
bv.getNormReference()[0] = 0x11;
assertFalse( Arrays.equals( BYTES_MOD, value ) );
}
@Test
public void testGetNormalizedValueReference() throws LdapException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertFalse( bv.isSchemaAware() );
bv.apply( at );
byte[] value = bv.getNormReference();
assertNull( value );
assertTrue( bv.isSchemaAware() );
bv = new BinaryValue( BYTES2 );
bv.apply( at );
value = bv.getNormReference();
assertTrue( Arrays.equals( BYTES1, value ) );
bv.getNormReference()[0] = 0x11;
assertTrue( Arrays.equals( BYTES_MOD, value ) );
}
@Test
public void testIsNull()
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertTrue( bv.isNull() );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
assertFalse( bv.isNull() );
bv = new BinaryValue( BYTES1 );
assertFalse( bv.isNull() );
}
@Test
public void testIsValid() throws LdapException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertTrue( bv.isValid( BINARY_CHECKER ) );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
assertTrue( bv.isValid( BINARY_CHECKER ) );
bv = new BinaryValue( BYTES1 );
assertFalse( bv.isNull() );
assertTrue( bv.isValid( BINARY_CHECKER ) );
bv = new BinaryValue( INVALID_BYTES );
assertFalse( bv.isNull() );
assertFalse( bv.isValid( BINARY_CHECKER ) );
}
@Test
public void testIsValidSyntaxChecker() throws LdapException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertTrue( bv.isValid( BINARY_CHECKER ) );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
assertTrue( bv.isValid( BINARY_CHECKER ) );
bv = new BinaryValue( BYTES1 );
assertTrue( bv.isValid( BINARY_CHECKER ) );
bv = new BinaryValue( INVALID_BYTES );
assertFalse( bv.isValid( BINARY_CHECKER ) );
}
@Test
public void testNormalize() throws LdapException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
bv.apply( at );
assertTrue( bv.isSchemaAware() );
assertEquals( null, bv.getNormValue() );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
bv.apply( at );
assertTrue( bv.isSchemaAware() );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, bv.getNormValue() ) );
bv = new BinaryValue( BYTES2 );
bv.apply( at );
assertTrue( bv.isSchemaAware() );
assertTrue( Arrays.equals( BYTES2, bv.getValue() ) );
assertTrue( Arrays.equals( BYTES1, bv.getNormValue() ) );
}
@Test
public void testSet() throws LdapException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertNull( bv.getValue() );
assertFalse( bv.isSchemaAware() );
assertTrue( bv.isValid( BINARY_CHECKER ) );
assertTrue( bv.isNull() );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
assertNotNull( bv.getValue() );
assertTrue( Arrays.equals( StringConstants.EMPTY_BYTES, bv.getBytes() ) );
assertFalse( bv.isSchemaAware() );
assertTrue( bv.isValid( BINARY_CHECKER ) );
assertFalse( bv.isNull() );
bv = new BinaryValue( BYTES1 );
assertNotNull( bv.getValue() );
assertTrue( Arrays.equals( BYTES1, bv.getBytes() ) );
assertFalse( bv.isSchemaAware() );
assertTrue( bv.isValid( BINARY_CHECKER ) );
assertFalse( bv.isNull() );
}
@Test
public void testIsNormalized() throws LdapException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertFalse( bv.isSchemaAware() );
bv = new BinaryValue( BYTES2 );
assertFalse( bv.isSchemaAware() );
bv.apply( at );
assertTrue( Arrays.equals( BYTES1, bv.getNormValue() ) );
assertTrue( bv.isSchemaAware() );
bv = new BinaryValue( BYTES2 );
assertFalse( bv.isSchemaAware() );
bv = new BinaryValue( BYTES_MOD );
assertFalse( bv.isSchemaAware() );
}
@Test
public void testSetNormalized() throws LdapException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
assertFalse( bv.isSchemaAware() );
bv = new BinaryValue( BYTES2 );
assertFalse( bv.isSchemaAware() );
bv.apply( at );
assertTrue( Arrays.equals( BYTES1, bv.getNormValue() ) );
assertTrue( bv.isSchemaAware() );
assertTrue( Arrays.equals( BYTES2, bv.getValue() ) );
}
/**
* Test the serialization of a CBV with a value and a normalized value
*/
@Test
public void testSerializeStandard() throws LdapException, IOException, ClassNotFoundException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
bv = new BinaryValue( BYTES2 );
bv.apply( at );
assertTrue( bv.isValid( BINARY_CHECKER ) );
BinaryValue cbvSer = deserializeValue( at, serializeValue( bv ) );
assertNotSame( bv, cbvSer );
assertTrue( Arrays.equals( bv.getReference(), cbvSer.getReference() ) );
assertTrue( Arrays.equals( bv.getNormReference(), cbvSer.getNormReference() ) );
assertTrue( cbvSer.isSchemaAware() );
}
/**
* Test the serialization of a CBV with a value and no normalized value
*/
@Test
public void testSerializeNotNormalized() throws LdapException, IOException, ClassNotFoundException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
bv = new BinaryValue( BYTES2 );
bv.isValid( BINARY_CHECKER );
BinaryValue cbvSer = deserializeValue( null, serializeValue( bv ) );
assertNotSame( bv, cbvSer );
assertTrue( Arrays.equals( bv.getReference(), cbvSer.getReference() ) );
assertTrue( Arrays.equals( bv.getReference(), cbvSer.getNormReference() ) );
assertFalse( cbvSer.isSchemaAware() );
}
/**
* Test the serialization of a CBV with a value and an empty normalized value
*/
@Test
public void testSerializeEmptyNormalized() throws LdapException, IOException, ClassNotFoundException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
bv = new BinaryValue( BYTES2 );
bv.isValid( BINARY_CHECKER );
bv.apply( at );
BinaryValue cbvSer = deserializeValue( at, serializeValue( bv ) );
assertNotSame( bv, cbvSer );
assertTrue( Arrays.equals( bv.getReference(), cbvSer.getReference() ) );
assertTrue( Arrays.equals( bv.getNormReference(), cbvSer.getNormReference() ) );
assertTrue( cbvSer.isSchemaAware() );
}
/**
* Test the serialization of a CBV with a null value
*/
@Test
public void testSerializeNullValue() throws LdapException, IOException, ClassNotFoundException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
bv = new BinaryValue( ( byte[] ) null );
bv.isValid( BINARY_CHECKER );
bv.apply( at );
BinaryValue cbvSer = deserializeValue( at, serializeValue( bv ) );
assertNotSame( bv, cbvSer );
assertTrue( Arrays.equals( bv.getReference(), cbvSer.getReference() ) );
assertTrue( Arrays.equals( bv.getNormReference(), cbvSer.getNormReference() ) );
assertTrue( cbvSer.isSchemaAware() );
}
/**
* Test the serialization of a CBV with an empty value
*/
@Test
public void testSerializeEmptyValue() throws LdapException, IOException, ClassNotFoundException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
bv.isValid( BINARY_CHECKER );
bv.apply( at );
BinaryValue cbvSer = deserializeValue( at, serializeValue( bv ) );
assertNotSame( bv, cbvSer );
assertTrue( Arrays.equals( bv.getReference(), cbvSer.getReference() ) );
assertTrue( Arrays.equals( bv.getNormReference(), cbvSer.getNormReference() ) );
assertTrue( cbvSer.isSchemaAware() );
}
/**
* Test the serialization of a CBV with an empty value not normalized
*/
@Test
public void testSerializeEmptyValueNotNormalized() throws LdapException, IOException, ClassNotFoundException
{
BinaryValue bv = new BinaryValue( ( byte[] ) null );
bv = new BinaryValue( StringConstants.EMPTY_BYTES );
bv.isValid( BINARY_CHECKER );
BinaryValue cbvSer = deserializeValue( null, serializeValue( bv ) );
assertNotSame( bv, cbvSer );
assertTrue( Arrays.equals( bv.getReference(), cbvSer.getReference() ) );
assertTrue( Arrays.equals( bv.getNormReference(), cbvSer.getNormReference() ) );
assertFalse( cbvSer.isSchemaAware() );
}
}