/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
* add the following below this CDDL HEADER, with the fields enclosed
* by brackets "[]" replaced with your own identifying information:
* Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
*
* Copyright 2006-2008 Sun Microsystems, Inc.
*/
package org.opends.server.controls;
import java.util.ArrayList;
import java.util.List;
import org.opends.server.api.MatchingRuleFactory;
import org.opends.server.api.MatchingRule;
import org.opends.server.core.DirectoryServer;
import org.opends.server.schema.BooleanEqualityMatchingRuleFactory;
import org.opends.server.schema.DistinguishedNameEqualityMatchingRuleFactory;
import org.opends.server.schema.IntegerEqualityMatchingRuleFactory;
import org.opends.server.types.*;
import org.opends.server.protocols.asn1.ASN1Writer;
import org.opends.server.protocols.asn1.ASN1;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import static org.testng.Assert.*;
/**
* Test MatchedValuesControl
*/
public class MatchedValuesControlTest
extends ControlsTestCase
{
/**
* Check "enum" values
*/
@Test
public void checkFilterValues() throws Exception
{
assertEquals(MatchedValuesFilter.EQUALITY_MATCH_TYPE, (byte) 0xA3);
assertEquals(MatchedValuesFilter.SUBSTRINGS_TYPE ,(byte)0xA4);
assertEquals(MatchedValuesFilter.GREATER_OR_EQUAL_TYPE,(byte)0xA5);
assertEquals(MatchedValuesFilter.LESS_OR_EQUAL_TYPE,(byte)0xA6);
assertEquals(MatchedValuesFilter.PRESENT_TYPE ,(byte)0x87);
assertEquals(MatchedValuesFilter.APPROXIMATE_MATCH_TYPE,(byte)0xA8);
assertEquals(MatchedValuesFilter.EXTENSIBLE_MATCH_TYPE,(byte)0xA9);
}
@DataProvider(name = "equalityFilterData")
public Object[][] createEqualityFilterData()
{
return new Object[][]
{
{ "description", "description" },
{ "objectclass", "top" },
{ "faketype", "fakevalue" }, };
}
/**
* Test createEqualityFilter
*/
@Test(dataProvider = "equalityFilterData")
public void checkCreateEqualityFilter(String type, String value)
throws Exception
{
MatchedValuesFilter mvf;
//
// ( String rawAttributeType, ASN1OctetStringrawAssertionValue)
//
// Check null, null
try
{
mvf = MatchedValuesFilter.createEqualityFilter((String) null,
(ByteString) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, null
try
{
mvf = MatchedValuesFilter.createEqualityFilter(type,
(ByteString) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
mvf = MatchedValuesFilter.createEqualityFilter(type, ByteString.valueOf(
value));
assertNotNull(mvf);
assertEquals(mvf.getRawAttributeType(), type);
assertEquals(mvf.getRawAssertionValue(), ByteString.valueOf(value));
assertEquals(mvf.getMatchType(), MatchedValuesFilter.EQUALITY_MATCH_TYPE);
checkEncodeDecode(mvf);
// Check null, value
try
{
mvf = MatchedValuesFilter.createEqualityFilter((String) null,
ByteString.valueOf(value));
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
//
// ( AttributeType attributeType, AttributeValue assertionValue
//
AttributeType attType = DirectoryServer.getAttributeType(type);
AttributeValue attVal = null;
if (attType != null)
{
attVal = AttributeValues.create(attType, value);
}
// Check null, null
try
{
mvf = MatchedValuesFilter.createEqualityFilter((AttributeType) null,
(AttributeValue) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, null
try
{
mvf = MatchedValuesFilter.createEqualityFilter(attType,
(AttributeValue) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, value
// As we provide dummy type and value string, attType and attVal
// could
// be null.
if ((attType != null) && (attVal != null))
{
mvf = MatchedValuesFilter.createEqualityFilter(attType, attVal);
assertNotNull(mvf);
assertEquals(mvf.getAttributeType(), attType);
assertEquals(mvf.getAssertionValue(), attVal);
assertEquals(mvf.getMatchType(), MatchedValuesFilter.EQUALITY_MATCH_TYPE);
checkEncodeDecode(mvf);
}
// Check null, value
try
{
mvf = MatchedValuesFilter.createEqualityFilter((AttributeType) null,
attVal);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
}
@DataProvider(name = "substringsFilterData")
public Object[][] createSubstringsFilterData()
{
ArrayList<String> l = new ArrayList<String>(3) ;
l.add("subAny") ;
l.add("o") ;
l.add("fakesubAny");
return new Object[][]
{
{ "description", "subInitial" ,l, "subFinal" },
{ "objectclass", "t", l,"p" },
{ "fakeobjecttype", "fakesubInitial" , l,"fakesubFinal"}, };
}
/**
* Test createEqualityFilter
*/
@Test(dataProvider = "substringsFilterData")
public void checkCreateSubstringsFilter(String type, String subInitial,
List<String> subAny, String subFinal) throws Exception
{
// input parameter
String rawAttTypeTest = type;
AttributeType attTypeTest = DirectoryServer.getAttributeType(type);
ByteString subInitialTest = ByteString.valueOf(subInitial);
List<ByteString> subAnyTest =
new ArrayList<ByteString>(subAny.size());
for (String s : subAny)
{
subAnyTest.add(ByteString.valueOf(s));
}
ByteString subFinalTest = ByteString.valueOf(subFinal);
// test parameter
AttributeType attTypeCurrent;
String rawAttTypeTestCurrent;
ByteString subInitialTestCurrent;
List<ByteString> subAnyTestCurrent;
ByteString subFinalTestCurrent;
for (int i = 0; i <= 15; i++)
{
attTypeCurrent = null;
rawAttTypeTestCurrent = null;
subInitialTestCurrent = null;
subAnyTestCurrent = null;
subFinalTestCurrent = null;
if ((i & 0x8) != 0) attTypeCurrent = attTypeTest;
if ((i & 0x8) != 0) rawAttTypeTestCurrent = rawAttTypeTest;
if ((i & 0x4) != 0) subInitialTestCurrent = subInitialTest;
if ((i & 0x2) != 0) subAnyTestCurrent = subAnyTest;
if ((i & 0x1) != 0) subFinalTestCurrent = subFinalTest;
if (attTypeCurrent == null)
{
rawAttTypeTestCurrent = null ;
}
boolean exceptionExpected = (attTypeCurrent == null);
try
{
MatchedValuesFilter mvf = MatchedValuesFilter.createSubstringsFilter(
rawAttTypeTestCurrent, subInitialTestCurrent, subAnyTestCurrent,
subFinalTestCurrent);
if (exceptionExpected)
{
assertTrue(false, "Expected NullPointerException");
}
assertNotNull(mvf);
assertEquals(mvf.getMatchType(), MatchedValuesFilter.SUBSTRINGS_TYPE);
assertEquals(rawAttTypeTestCurrent, mvf.getRawAttributeType());
if (subInitialTestCurrent == null)
{
assertNull(mvf.getSubInitialElement());
}
else
{
assertEquals(subInitialTestCurrent, mvf.getSubInitialElement());
}
if (subAnyTestCurrent == null)
{
assertNull(mvf.getSubAnyElements());
}
else
{
List<ByteString> ret = mvf.getSubAnyElements();
assertNotNull(ret);
assertEquals(subAnyTestCurrent.size(), ret.size());
for (ByteString r : ret)
{
assertTrue(subAnyTestCurrent.contains(r));
}
if (subFinalTestCurrent == null)
{
assertNull(mvf.getSubFinalElement());
}
else
{
assertEquals(subFinalTestCurrent, mvf.getSubFinalElement());
}
mvf = MatchedValuesFilter.createSubstringsFilter(attTypeCurrent,
subInitialTestCurrent, subAnyTestCurrent, subFinalTestCurrent);
assertNotNull(mvf);
assertEquals(mvf.getMatchType(), MatchedValuesFilter.SUBSTRINGS_TYPE);
assertEquals(attTypeCurrent, mvf.getAttributeType());
if (subInitialTestCurrent == null)
{
assertNull(mvf.getSubInitialElement());
}
else
{
assertEquals(subInitialTestCurrent, mvf.getSubInitialElement());
}
ret = mvf.getSubAnyElements();
assertNotNull(ret);
assertEquals(subAnyTestCurrent.size(), ret.size());
for (ByteString r : ret)
{
assertTrue(subAnyTestCurrent.contains(r));
}
if (subFinalTestCurrent == null)
{
assertNull(mvf.getSubFinalElement());
}
else
{
assertEquals(subFinalTestCurrent, mvf.getSubFinalElement());
}
}
}
catch (Throwable t)
{
if ( ! exceptionExpected)
{
assertTrue(false, "Exception not excepted: " + t.getMessage());
}
}
}
}
/**
* Test GreaterOrEqualFilter
*/
@Test(dataProvider = "equalityFilterData")
public void checkGreaterOrEqualFilter(String type, String value)
throws Exception
{
MatchedValuesFilter mvf;
//
// ( String rawAttributeType, ASN1OctetStringrawAssertionValue)
//
// Check null, null
try
{
mvf = MatchedValuesFilter.createGreaterOrEqualFilter((String) null,
(ByteString) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, null
try
{
mvf = MatchedValuesFilter.createGreaterOrEqualFilter(type,
(ByteString) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, value
// As we provide dummy type and value string, attType and attVal
// could
// be null.
if ((type != null) && (value != null))
{
mvf = MatchedValuesFilter.createGreaterOrEqualFilter(type,
ByteString.valueOf(value));
assertNotNull(mvf);
assertEquals(mvf.getRawAttributeType(), type);
assertEquals(mvf.getRawAssertionValue(), ByteString.valueOf(value));
assertEquals(mvf.getMatchType(),
MatchedValuesFilter.GREATER_OR_EQUAL_TYPE);
}
// Check null, value
try
{
mvf = MatchedValuesFilter.createGreaterOrEqualFilter((String) null,
ByteString.valueOf(value));
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
//
// ( AttributeType attributeType, AttributeValue assertionValue
//
AttributeType attType = DirectoryServer.getAttributeType(type);
AttributeValue attVal = null;
if (attType != null)
{
attVal = AttributeValues.create(attType, value);
}
// Check null, null
try
{
mvf = MatchedValuesFilter.createGreaterOrEqualFilter(
(AttributeType) null, (AttributeValue) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, null
try
{
mvf = MatchedValuesFilter.createGreaterOrEqualFilter(attType,
(AttributeValue) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, value
if ((attType != null) && (attVal != null))
{
mvf = MatchedValuesFilter.createGreaterOrEqualFilter(attType, attVal);
assertNotNull(mvf);
assertEquals(mvf.getAttributeType(), attType);
assertEquals(mvf.getAssertionValue(), attVal);
assertEquals(mvf.getMatchType(),
MatchedValuesFilter.GREATER_OR_EQUAL_TYPE);
}
// Check null, value
try
{
mvf = MatchedValuesFilter.createGreaterOrEqualFilter(
(AttributeType) null, attVal);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
}
/**
* Test LessOrEqualFilter
*/
@Test(dataProvider = "equalityFilterData")
public void checkLessOrEqualFilter(String type, String value)
throws Exception
{
//
// ( String rawAttributeType, ASN1OctetStringrawAssertionValue)
//
// Check null, null
MatchedValuesFilter mvf;
try
{
mvf = MatchedValuesFilter.createLessOrEqualFilter((String) null,
(ByteString) null);
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, null
try
{
mvf = MatchedValuesFilter.createLessOrEqualFilter(type,
(ByteString) null);
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, value
mvf = MatchedValuesFilter.createLessOrEqualFilter(type,
ByteString.valueOf(value));
assertNotNull(mvf);
assertEquals(mvf.getRawAttributeType(), type);
assertEquals(mvf.getRawAssertionValue(), ByteString.valueOf(value));
assertEquals(mvf.getMatchType(), MatchedValuesFilter.LESS_OR_EQUAL_TYPE);
// Check null, value
try
{
mvf = MatchedValuesFilter.createLessOrEqualFilter((String) null,
ByteString.valueOf(value));
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
;
//
// ( AttributeType attributeType, AttributeValue assertionValue
//
AttributeType attType = DirectoryServer.getAttributeType(type);
AttributeValue attVal = null ;
if (attType != null)
{
attVal = AttributeValues.create(attType, value);
}
// Check null, null
try
{
mvf = MatchedValuesFilter.createLessOrEqualFilter((AttributeType) null,
(AttributeValue) null);
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, null
try
{
mvf = MatchedValuesFilter.createLessOrEqualFilter(attType,
(AttributeValue) null);
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, value
// As we provide dummy type and value string, attType and attVal
// could
// be null.
if ((attType != null) && (attVal != null))
{
mvf = MatchedValuesFilter.createLessOrEqualFilter(attType, attVal);
assertNotNull(mvf);
assertEquals(mvf.getAttributeType(), attType);
assertEquals(mvf.getAssertionValue(), attVal);
assertEquals(mvf.getMatchType(), MatchedValuesFilter.LESS_OR_EQUAL_TYPE);
}
// Check null, value
try
{
mvf = MatchedValuesFilter.createLessOrEqualFilter((AttributeType) null,
attVal);
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
}
/**
* Test PresentFilter
*/
@Test(dataProvider = "equalityFilterData")
public void checkPresentFilter(
String type, String value) throws Exception
{
//
// ( String rawAttributeType)
//
// Check null
MatchedValuesFilter mvf = null;
try
{
mvf = MatchedValuesFilter.createPresentFilter((String) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type
mvf = MatchedValuesFilter.createPresentFilter(type);
assertNotNull(mvf);
assertEquals(mvf.getRawAttributeType(), type);
assertEquals(mvf.getMatchType(), MatchedValuesFilter.PRESENT_TYPE);
//
// ( AttributeType attributeType
//
AttributeType attType = DirectoryServer.getAttributeType(type);
// Check null
try
{
mvf = MatchedValuesFilter.createPresentFilter((AttributeType) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// excepted behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type,
if (attType != null)
{
mvf = MatchedValuesFilter.createPresentFilter(attType);
assertNotNull(mvf);
assertEquals(mvf.getAttributeType(), attType);
assertEquals(mvf.getMatchType(), MatchedValuesFilter.PRESENT_TYPE);
}
}
/**
* Test ApproximateFilter
*/
@Test(dataProvider = "equalityFilterData")
public void checkApproximateFilter(String type, String value)
throws Exception
{
MatchedValuesFilter mvf;
//
// ( String rawAttributeType, ASN1OctetStringrawAssertionValue)
//
// Check null, null
try
{
mvf = MatchedValuesFilter.createApproximateFilter((String) null,
(ByteString) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// expected behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, null
try
{
mvf = MatchedValuesFilter.createApproximateFilter(type,
(ByteString) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// expected behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, value
mvf = MatchedValuesFilter.createApproximateFilter(type,
ByteString.valueOf(value));
assertNotNull(mvf);
assertEquals(mvf.getRawAttributeType(), type);
assertEquals(mvf.getRawAssertionValue(), ByteString.valueOf(value));
assertEquals(mvf.getMatchType(), MatchedValuesFilter.APPROXIMATE_MATCH_TYPE);
// Check null, value
try
{
mvf = MatchedValuesFilter.createApproximateFilter((String) null,
ByteString.valueOf(value));
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// expected behavior
}
catch (AssertionError e)
{
// excepted behavior
}
//
// ( AttributeType attributeType, AttributeValue assertionValue
//
AttributeType attType = DirectoryServer.getAttributeType(type);
AttributeValue attVal = null ;
if (attType != null)
{
attVal = AttributeValues.create(attType, value);
}
// Check null, null
try
{
mvf = MatchedValuesFilter.createApproximateFilter((AttributeType) null,
(AttributeValue) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// expected behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, null
try
{
mvf = MatchedValuesFilter.createApproximateFilter(attType,
(AttributeValue) null);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// expected behavior
}
catch (AssertionError e)
{
// excepted behavior
}
// Check type, value
// As we provide dummy type and value string, attType and attVal could
// be null.
if ((attType != null) && (attVal != null))
{
mvf = MatchedValuesFilter.createApproximateFilter(attType, attVal);
assertNotNull(mvf);
assertEquals(mvf.getAttributeType(), attType);
assertEquals(mvf.getAssertionValue(), attVal);
assertEquals(mvf.getMatchType(),
MatchedValuesFilter.APPROXIMATE_MATCH_TYPE);
}
// Check null, value
try
{
mvf = MatchedValuesFilter.createApproximateFilter((AttributeType) null,
attVal);
assertTrue(false, "Expected NullPointerException");
}
catch (NullPointerException e)
{
// expected behavior
}
catch (AssertionError e)
{
// excepted behavior
}
}
@DataProvider(name = "extensibleMatchFilterData")
public Object[][] createExtensibleMatchFilterData() throws Exception
{
MatchingRuleFactory<?> factory = new BooleanEqualityMatchingRuleFactory();
factory.initializeMatchingRule(null);
MatchingRule booleanEquality = factory.getMatchingRules().iterator().next();
factory = new IntegerEqualityMatchingRuleFactory();
factory.initializeMatchingRule(null);
MatchingRule integerEquality = factory.getMatchingRules().iterator().next();
factory = new DistinguishedNameEqualityMatchingRuleFactory();
factory.initializeMatchingRule(null);
MatchingRule distinguishedEquality = factory.getMatchingRules().iterator().next();
return new Object[][]
{
{ "description", booleanEquality, "description" },
{ "objectclass", integerEquality ,"top" },
{ "fakeobjecttype", distinguishedEquality, "fakevalue" }, };
}
/**
* Test ExtensibleMatchFilter
*/
@Test(dataProvider = "extensibleMatchFilterData")
public void checkExtensibleMatchFilter(
String type, MatchingRule matchingRule, String value)
throws Exception
{
// input value
String rawAttTypeTest = type ;
AttributeType attTypeTest = DirectoryServer.getAttributeType(type) ;
String matchingRuleIdTest = matchingRule.getOID() ;
ByteString rawAttValueTest = (attTypeTest == null) ? null : ByteString.valueOf(value);
AttributeValue attValueTest = (attTypeTest == null) ? null : AttributeValues.create(attTypeTest, value);
//
// parameter used for the test.
String rawAttTypeTestCurrent;
AttributeType attTypeTestCurrent ;
String rawMatchingRuleidTestCurrent ;
MatchingRule matchingRuleidTestCurrent ;
ByteString rawAttValueTestCurrent;
AttributeValue attValueTestCurrent;
for (int i= 0 ; i <= 7 ; i++)
{
rawAttTypeTestCurrent = null;
rawMatchingRuleidTestCurrent = null;
matchingRuleidTestCurrent = null ;
rawAttValueTestCurrent = null;
attTypeTestCurrent = null;
attValueTestCurrent = null ;
if ((i & 0x4) != 0) attTypeTestCurrent = attTypeTest;
if ((i & 0x4) != 0) rawAttTypeTestCurrent = rawAttTypeTest;
if ((i & 0x2) != 0) rawMatchingRuleidTestCurrent = matchingRuleIdTest;
if ((i & 0x2) != 0) matchingRuleidTestCurrent = matchingRule ;
if ((i & 0x1) != 0) rawAttValueTestCurrent = rawAttValueTest;
if ((i & 0x1) != 0) attValueTestCurrent = attValueTest;
boolean exceptionExpected = (attTypeTestCurrent == null)
|| (attValueTestCurrent == null) || (matchingRuleidTestCurrent == null);
MatchedValuesFilter mvf = null;
try
{
// Create filter with raw value
mvf = MatchedValuesFilter.createExtensibleMatchFilter(rawAttTypeTestCurrent,
rawMatchingRuleidTestCurrent, rawAttValueTestCurrent);
if ( exceptionExpected)
{
assertTrue(false, "Expected NullPointerException");
}
else
{
assertNotNull(mvf);
assertEquals(mvf.getMatchType(),
MatchedValuesFilter.EXTENSIBLE_MATCH_TYPE);
assertEquals(rawMatchingRuleidTestCurrent, mvf.getMatchingRuleID());
assertEquals(rawAttValueTestCurrent, mvf.getRawAssertionValue());
mvf = MatchedValuesFilter.createExtensibleMatchFilter(
attTypeTestCurrent, matchingRuleidTestCurrent, attValueTestCurrent);
assertNotNull(mvf);
assertEquals(mvf.getMatchType(),
MatchedValuesFilter.EXTENSIBLE_MATCH_TYPE);
assertEquals(matchingRuleidTestCurrent, mvf.getMatchingRule());
assertEquals(attValueTestCurrent, mvf.getAssertionValue());
}
}
catch (Throwable t)
{
if ( ! exceptionExpected)
{
assertTrue(false, "Exception not excepted" + t.getMessage());
}
}
}
}
/**
* Check encode/decode method
*/
private void checkEncodeDecode(MatchedValuesFilter mvf)
{
ByteStringBuilder bsb = new ByteStringBuilder();
ASN1Writer writer = ASN1.getWriter(bsb);
try
{
mvf.encode(writer);
MatchedValuesFilter newMvf = MatchedValuesFilter.decode(ASN1
.getReader(bsb));
assertEquals(newMvf.toString(), mvf.toString());
}
catch (Exception e)
{
assertTrue(false, "Unexpected LDAPException ; msg=" + e.getMessage());
}
}
}