From be4a946166d4f711fe9ed622e07a7c9049b8b29c Mon Sep 17 00:00:00 2001
From: lutoff <lutoff@localhost>
Date: Thu, 09 Nov 2006 14:24:42 +0000
Subject: [PATCH] Issue: 748 Synopsis: Controls/MatchedValuesFilter: invalid parameters are not rejected when MatchedValuesFilter are created.
---
opends/tests/unit-tests-testng/src/server/org/opends/server/controls/MatchedValuesControlTest.java | 963 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
opends/src/server/org/opends/server/controls/MatchedValuesFilter.java | 56 +--
2 files changed, 985 insertions(+), 34 deletions(-)
diff --git a/opends/src/server/org/opends/server/controls/MatchedValuesFilter.java b/opends/src/server/org/opends/server/controls/MatchedValuesFilter.java
index 58cbb2f..f818c3f 100644
--- a/opends/src/server/org/opends/server/controls/MatchedValuesFilter.java
+++ b/opends/src/server/org/opends/server/controls/MatchedValuesFilter.java
@@ -47,6 +47,7 @@
import org.opends.server.types.AttributeValue;
import org.opends.server.types.ByteString;
import org.opends.server.types.ConditionResult;
+import org.opends.server.util.Validator;
import static org.opends.server.loggers.Debug.*;
import static org.opends.server.messages.MessageHandler.*;
@@ -244,6 +245,7 @@
String.valueOf(rawAttributeType),
String.valueOf(rawAssertionValue));
+ Validator.ensureNotNull(rawAttributeType,rawAssertionValue);
return new MatchedValuesFilter(EQUALITY_MATCH_TYPE, rawAttributeType,
rawAssertionValue, null, null, null, null);
@@ -268,16 +270,10 @@
String.valueOf(assertionValue));
- String rawAttributeType = null ;
- ASN1OctetString rawAssertionValue = null ;
- if (attributeType != null)
- {
- rawAttributeType = attributeType.getNameOrOID();
- }
- if (assertionValue != null)
- {
- rawAssertionValue = assertionValue.getValue().toASN1OctetString();
- }
+ Validator.ensureNotNull(attributeType, assertionValue);
+ String rawAttributeType = attributeType.getNameOrOID();
+ ASN1OctetString rawAssertionValue = assertionValue.getValue()
+ .toASN1OctetString();
MatchedValuesFilter filter =
new MatchedValuesFilter(EQUALITY_MATCH_TYPE, rawAttributeType,
@@ -312,6 +308,7 @@
String.valueOf(subFinal));
+ Validator.ensureNotNull(rawAttributeType);
return new MatchedValuesFilter(SUBSTRINGS_TYPE, rawAttributeType, null,
subInitial, subAny, subFinal, null);
}
@@ -339,6 +336,7 @@
String.valueOf(subAny), String.valueOf(subFinal));
+ Validator.ensureNotNull(attributeType);
String rawAttributeType = attributeType.getNameOrOID();
MatchedValuesFilter filter =
@@ -367,6 +365,7 @@
String.valueOf(rawAttributeType),
String.valueOf(rawAssertionValue));
+ Validator.ensureNotNull(rawAttributeType, rawAssertionValue);
return new MatchedValuesFilter(GREATER_OR_EQUAL_TYPE, rawAttributeType,
rawAssertionValue, null, null, null, null);
@@ -390,6 +389,7 @@
String.valueOf(attributeType),
String.valueOf(assertionValue));
+ Validator.ensureNotNull(attributeType, assertionValue);
String rawAttributeType = attributeType.getNameOrOID();
ASN1OctetString rawAssertionValue =
@@ -423,6 +423,7 @@
String.valueOf(rawAssertionValue));
+ Validator.ensureNotNull(rawAttributeType, rawAssertionValue);
return new MatchedValuesFilter(LESS_OR_EQUAL_TYPE, rawAttributeType,
rawAssertionValue, null, null, null, null);
}
@@ -445,6 +446,7 @@
String.valueOf(attributeType),
String.valueOf(assertionValue));
+ Validator.ensureNotNull(attributeType, assertionValue);
String rawAttributeType = attributeType.getNameOrOID();
ASN1OctetString rawAssertionValue =
@@ -473,7 +475,7 @@
assert debugEnter(CLASS_NAME, "createPresentFilter",
String.valueOf(rawAttributeType));
-
+ Validator.ensureNotNull(rawAttributeType) ;
return new MatchedValuesFilter(PRESENT_TYPE, rawAttributeType, null, null,
null, null, null);
}
@@ -493,7 +495,7 @@
assert debugEnter(CLASS_NAME, "createPresentFilter",
String.valueOf(attributeType));
-
+ Validator.ensureNotNull(attributeType);
String rawAttributeType = attributeType.getNameOrOID();
MatchedValuesFilter filter =
@@ -522,6 +524,7 @@
String.valueOf(rawAttributeType),
String.valueOf(rawAssertionValue));
+ Validator.ensureNotNull(rawAttributeType,rawAssertionValue);
return new MatchedValuesFilter(APPROXIMATE_MATCH_TYPE, rawAttributeType,
rawAssertionValue, null, null, null, null);
@@ -546,6 +549,7 @@
String.valueOf(assertionValue));
+ Validator.ensureNotNull(attributeType,assertionValue);
String rawAttributeType = attributeType.getNameOrOID();
ASN1OctetString rawAssertionValue =
assertionValue.getValue().toASN1OctetString();
@@ -580,7 +584,8 @@
String.valueOf(matchingRuleID),
String.valueOf(rawAssertionValue));
-
+ Validator
+ .ensureNotNull(rawAttributeType, matchingRuleID, rawAssertionValue);
return new MatchedValuesFilter(EXTENSIBLE_MATCH_TYPE, rawAttributeType,
rawAssertionValue, null, null, null,
matchingRuleID);
@@ -608,31 +613,14 @@
String.valueOf(assertionValue));
- String rawAttributeType;
- if (attributeType == null)
- {
- rawAttributeType = null;
- }
- else
- {
- rawAttributeType = attributeType.getNameOrOID();
- }
-
- String matchingRuleID;
- if (matchingRule == null)
- {
- matchingRuleID = null;
- }
- else
- {
- matchingRuleID = matchingRule.getOID();
- }
-
+ Validator.ensureNotNull(attributeType, matchingRule, assertionValue);
+ String rawAttributeType = attributeType.getNameOrOID();
+ String matchingRuleID = matchingRule.getOID();
ASN1OctetString rawAssertionValue =
assertionValue.getValue().toASN1OctetString();
MatchedValuesFilter filter =
- new MatchedValuesFilter(APPROXIMATE_MATCH_TYPE, rawAttributeType,
+ new MatchedValuesFilter(EXTENSIBLE_MATCH_TYPE, rawAttributeType,
rawAssertionValue, null, null, null,
matchingRuleID);
filter.attributeType = attributeType;
diff --git a/opends/tests/unit-tests-testng/src/server/org/opends/server/controls/MatchedValuesControlTest.java b/opends/tests/unit-tests-testng/src/server/org/opends/server/controls/MatchedValuesControlTest.java
new file mode 100644
index 0000000..55dd1c7
--- /dev/null
+++ b/opends/tests/unit-tests-testng/src/server/org/opends/server/controls/MatchedValuesControlTest.java
@@ -0,0 +1,963 @@
+/*
+ * 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
+ *
+ *
+ * Portions Copyright 2006 Sun Microsystems, Inc.
+ */
+package org.opends.server.controls;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opends.server.api.MatchingRule;
+import org.opends.server.core.DirectoryServer;
+import org.opends.server.protocols.asn1.ASN1Element;
+import org.opends.server.protocols.asn1.ASN1OctetString;
+import org.opends.server.protocols.ldap.LDAPException;
+import org.opends.server.schema.BooleanEqualityMatchingRule;
+import org.opends.server.schema.DistinguishedNameEqualityMatchingRule;
+import org.opends.server.schema.IntegerEqualityMatchingRule;
+import org.opends.server.types.AttributeType;
+import org.opends.server.types.AttributeValue;
+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,
+ (ASN1OctetString) null);
+ assertTrue(false, "Expected NullPointerException");
+ }
+ catch (NullPointerException e)
+ {
+ // excepted behavior
+ }
+ catch (AssertionError e)
+ {
+ // excepted behavior
+ }
+
+ // Check type, null
+ try
+ {
+ mvf = MatchedValuesFilter.createEqualityFilter(type,
+ (ASN1OctetString) null);
+ assertTrue(false, "Expected NullPointerException");
+ }
+ catch (NullPointerException e)
+ {
+ // excepted behavior
+ }
+ catch (AssertionError e)
+ {
+ // excepted behavior
+ }
+
+ mvf = MatchedValuesFilter.createEqualityFilter(type, new ASN1OctetString(
+ value));
+ assertNotNull(mvf);
+ assertEquals(mvf.getRawAttributeType(), type);
+ assertEquals(mvf.getRawAssertionValue(), new ASN1OctetString(value));
+ assertEquals(mvf.getMatchType(), MatchedValuesFilter.EQUALITY_MATCH_TYPE);
+ checkEncodeDecode(mvf);
+
+ // Check null, value
+ try
+ {
+ mvf = MatchedValuesFilter.createEqualityFilter((String) null,
+ new ASN1OctetString(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 = new AttributeValue(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);
+ ASN1OctetString subInitialTest = new ASN1OctetString(subInitial);
+ List<ASN1OctetString> subAnyTest =
+ new ArrayList<ASN1OctetString>(subAny.size());
+ for (String s : subAny)
+ {
+ subAnyTest.add(new ASN1OctetString(s));
+ }
+ ASN1OctetString subFinalTest = new ASN1OctetString(subFinal);
+
+ // test parameter
+ AttributeType attTypeCurrent;
+ String rawAttTypeTestCurrent;
+ ASN1OctetString subInitialTestCurrent;
+ List<ASN1OctetString> subAnyTestCurrent;
+ ASN1OctetString 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<ASN1OctetString> ret = mvf.getSubAnyElements();
+ assertNotNull(ret);
+ assertEquals(subAnyTestCurrent.size(), ret.size());
+ for (ASN1OctetString 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());
+ }
+
+ if (subAnyTestCurrent == null)
+ {
+ assertNull(mvf.getSubAnyElements());
+ }
+ else
+ {
+ ret = mvf.getSubAnyElements();
+ assertNotNull(ret);
+ assertEquals(subAnyTestCurrent.size(), ret.size());
+ for (ASN1OctetString r : ret)
+ {
+ assertTrue(subAnyTestCurrent.contains(r));
+ }
+ }
+ if (subFinalTestCurrent == null)
+ {
+ assertNull(mvf.getSubFinalElement());
+ }
+ else
+ {
+ assertEquals(subFinalTestCurrent, mvf.getSubFinalElement());
+ }
+ }
+ }
+ catch (Exception e)
+ {
+ if ( ! exceptionExpected)
+ {
+ assertTrue(false, "Exception not excepted: " + e.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,
+ (ASN1OctetString) null);
+ assertTrue(false, "Expected NullPointerException");
+ }
+ catch (NullPointerException e)
+ {
+ // excepted behavior
+ }
+ catch (AssertionError e)
+ {
+ // excepted behavior
+ }
+
+ // Check type, null
+ try
+ {
+ mvf = MatchedValuesFilter.createGreaterOrEqualFilter(type,
+ (ASN1OctetString) 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,
+ new ASN1OctetString(value));
+ assertNotNull(mvf);
+ assertEquals(mvf.getRawAttributeType(), type);
+ assertEquals(mvf.getRawAssertionValue(), new ASN1OctetString(value));
+ assertEquals(mvf.getMatchType(),
+ MatchedValuesFilter.GREATER_OR_EQUAL_TYPE);
+ }
+
+ // Check null, value
+ try
+ {
+ mvf = MatchedValuesFilter.createGreaterOrEqualFilter((String) null,
+ new ASN1OctetString(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 = new AttributeValue(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,
+ (ASN1OctetString) null);
+ }
+ catch (NullPointerException e)
+ {
+ // excepted behavior
+ }
+ catch (AssertionError e)
+ {
+ // excepted behavior
+ }
+
+ // Check type, null
+ try
+ {
+ mvf = MatchedValuesFilter.createLessOrEqualFilter(type,
+ (ASN1OctetString) null);
+ }
+ catch (NullPointerException e)
+ {
+ // excepted behavior
+ }
+ catch (AssertionError e)
+ {
+ // excepted behavior
+ }
+
+ // Check type, value
+ mvf = MatchedValuesFilter.createLessOrEqualFilter(type,
+ new ASN1OctetString(value));
+ assertNotNull(mvf);
+ assertEquals(mvf.getRawAttributeType(), type);
+ assertEquals(mvf.getRawAssertionValue(), new ASN1OctetString(value));
+ assertEquals(mvf.getMatchType(), MatchedValuesFilter.LESS_OR_EQUAL_TYPE);
+
+ // Check null, value
+ try
+ {
+ mvf = MatchedValuesFilter.createLessOrEqualFilter((String) null,
+ new ASN1OctetString(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)
+ {
+ new AttributeValue(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,
+ (ASN1OctetString) null);
+ assertTrue(false, "Expected NullPointerException");
+ }
+ catch (NullPointerException e)
+ {
+ // expected behavior
+ }
+ catch (AssertionError e)
+ {
+ // excepted behavior
+ }
+
+ // Check type, null
+ try
+ {
+ mvf = MatchedValuesFilter.createApproximateFilter(type,
+ (ASN1OctetString) null);
+ assertTrue(false, "Expected NullPointerException");
+ }
+ catch (NullPointerException e)
+ {
+ // expected behavior
+ }
+ catch (AssertionError e)
+ {
+ // excepted behavior
+ }
+
+ // Check type, value
+ mvf = MatchedValuesFilter.createApproximateFilter(type,
+ new ASN1OctetString(value));
+ assertNotNull(mvf);
+ assertEquals(mvf.getRawAttributeType(), type);
+ assertEquals(mvf.getRawAssertionValue(), new ASN1OctetString(value));
+ assertEquals(mvf.getMatchType(), MatchedValuesFilter.APPROXIMATE_MATCH_TYPE);
+
+ // Check null, value
+ try
+ {
+ mvf = MatchedValuesFilter.createApproximateFilter((String) null,
+ new ASN1OctetString(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 = new AttributeValue(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()
+ {
+
+ return new Object[][]
+ {
+ { "description", new BooleanEqualityMatchingRule(), "description" },
+ { "objectclass", new IntegerEqualityMatchingRule() ,"top" },
+ { "fakeobjecttype", new DistinguishedNameEqualityMatchingRule(), "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() ;
+ ASN1OctetString rawAttValueTest = (attTypeTest == null) ? null : new ASN1OctetString(value);
+ AttributeValue attValueTest = (attTypeTest == null) ? null : new AttributeValue(attTypeTest, value);
+ //
+ // parameter used for the test.
+ String rawAttTypeTestCurrent;
+ AttributeType attTypeTestCurrent ;
+ String rawMatchingRuleidTestCurrent ;
+ MatchingRule matchingRuleidTestCurrent ;
+ ASN1OctetString 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 (Exception e)
+ {
+ if ( ! exceptionExpected)
+ {
+ assertTrue(false, "Exception not excepted" + e.getMessage());
+ }
+ }
+ }
+ }
+
+ /**
+ * Check encode/decode method
+ */
+ private void checkEncodeDecode(MatchedValuesFilter mvf)
+ {
+ ASN1Element asn1Elt = mvf.encode() ;
+ try
+ {
+ MatchedValuesFilter newMvf = MatchedValuesFilter.decode(asn1Elt) ;
+ assertEquals(newMvf.toString(), mvf.toString());
+ }
+ catch (LDAPException e)
+ {
+ assertTrue(false, "Unexpected LDAPException ; msg=" + e.getMessage());
+ }
+
+ }
+}
--
Gitblit v1.10.0