diff --git a/src/main/java/net/sourceforge/myvd/inserts/ldap/LDAPInterceptor.java b/src/main/java/net/sourceforge/myvd/inserts/ldap/LDAPInterceptor.java
index 4a51720..7451531 100644
--- a/src/main/java/net/sourceforge/myvd/inserts/ldap/LDAPInterceptor.java
+++ b/src/main/java/net/sourceforge/myvd/inserts/ldap/LDAPInterceptor.java
@@ -415,6 +415,10 @@ public void search(SearchInterceptorChain chain, DistinguishedName base,
             if (remoteBase == null) {
                 remoteBase = "";
             }
+            
+            if (remoteBase.contains("\\+")) {
+            	remoteBase = remoteBase.replace("\\+", "+");
+            }
 
             if (this.usePaging) {
                 if (constraints != null) {
diff --git a/src/main/java/net/sourceforge/myvd/inserts/mapping/ClearMultiValueRDNEscapesFilter.java b/src/main/java/net/sourceforge/myvd/inserts/mapping/ClearMultiValueRDNEscapesFilter.java
new file mode 100644
index 0000000..316669a
--- /dev/null
+++ b/src/main/java/net/sourceforge/myvd/inserts/mapping/ClearMultiValueRDNEscapesFilter.java
@@ -0,0 +1,136 @@
+package net.sourceforge.myvd.inserts.mapping;
+
+import java.util.ArrayList;
+import java.util.Properties;
+
+import com.novell.ldap.LDAPConstraints;
+import com.novell.ldap.LDAPException;
+import com.novell.ldap.LDAPModification;
+import com.novell.ldap.LDAPSearchConstraints;
+
+import net.sourceforge.myvd.chain.AddInterceptorChain;
+import net.sourceforge.myvd.chain.BindInterceptorChain;
+import net.sourceforge.myvd.chain.CompareInterceptorChain;
+import net.sourceforge.myvd.chain.DeleteInterceptorChain;
+import net.sourceforge.myvd.chain.ExetendedOperationInterceptorChain;
+import net.sourceforge.myvd.chain.ModifyInterceptorChain;
+import net.sourceforge.myvd.chain.PostSearchCompleteInterceptorChain;
+import net.sourceforge.myvd.chain.PostSearchEntryInterceptorChain;
+import net.sourceforge.myvd.chain.RenameInterceptorChain;
+import net.sourceforge.myvd.chain.SearchInterceptorChain;
+import net.sourceforge.myvd.core.NameSpace;
+import net.sourceforge.myvd.inserts.Insert;
+import net.sourceforge.myvd.types.Attribute;
+import net.sourceforge.myvd.types.Bool;
+import net.sourceforge.myvd.types.DistinguishedName;
+import net.sourceforge.myvd.types.Entry;
+import net.sourceforge.myvd.types.ExtendedOperation;
+import net.sourceforge.myvd.types.Filter;
+import net.sourceforge.myvd.types.Int;
+import net.sourceforge.myvd.types.Password;
+import net.sourceforge.myvd.types.Results;
+
+public class ClearMultiValueRDNEscapesFilter implements Insert {
+
+	String name;
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public void configure(String name, Properties props, NameSpace nameSpace) throws LDAPException {
+		this.name = name;
+
+	}
+
+	@Override
+	public void add(AddInterceptorChain chain, Entry entry, LDAPConstraints constraints) throws LDAPException {
+		chain.nextAdd(entry, constraints);
+
+	}
+
+	@Override
+	public void bind(BindInterceptorChain chain, DistinguishedName dn, Password pwd, LDAPConstraints constraints)
+			throws LDAPException {
+		chain.nextBind(dn, pwd, constraints);
+
+	}
+
+	@Override
+	public void compare(CompareInterceptorChain chain, DistinguishedName dn, Attribute attrib,
+			LDAPConstraints constraints) throws LDAPException {
+		chain.nextCompare(dn, attrib, constraints);
+
+	}
+
+	@Override
+	public void delete(DeleteInterceptorChain chain, DistinguishedName dn, LDAPConstraints constraints)
+			throws LDAPException {
+		chain.nextDelete(dn, constraints);
+
+	}
+
+	@Override
+	public void extendedOperation(ExetendedOperationInterceptorChain chain, ExtendedOperation op,
+			LDAPConstraints constraints) throws LDAPException {
+		chain.nextExtendedOperations(op, constraints);
+
+	}
+
+	@Override
+	public void modify(ModifyInterceptorChain chain, DistinguishedName dn, ArrayList<LDAPModification> mods,
+			LDAPConstraints constraints) throws LDAPException {
+		chain.nextModify(dn, mods, constraints);
+
+	}
+
+	@Override
+	public void search(SearchInterceptorChain chain, DistinguishedName base, Int scope, Filter filter,
+			ArrayList<Attribute> attributes, Bool typesOnly, Results results, LDAPSearchConstraints constraints)
+			throws LDAPException {
+		String strFilter = filter.getValue();
+		strFilter = strFilter.replace("\\+", "+");
+		Filter nfilter = new Filter(strFilter);
+		
+		chain.nextSearch(base, scope, nfilter, attributes, typesOnly, results, constraints);
+
+	}
+
+	@Override
+	public void rename(RenameInterceptorChain chain, DistinguishedName dn, DistinguishedName newRdn, Bool deleteOldRdn,
+			LDAPConstraints constraints) throws LDAPException {
+		chain.nextRename(dn, newRdn, deleteOldRdn, constraints);
+
+	}
+
+	@Override
+	public void rename(RenameInterceptorChain chain, DistinguishedName dn, DistinguishedName newRdn,
+			DistinguishedName newParentDN, Bool deleteOldRdn, LDAPConstraints constraints) throws LDAPException {
+		chain.nextRename(dn, newRdn, newParentDN, deleteOldRdn, constraints);
+
+	}
+
+	@Override
+	public void postSearchEntry(PostSearchEntryInterceptorChain chain, Entry entry, DistinguishedName base, Int scope,
+			Filter filter, ArrayList<Attribute> attributes, Bool typesOnly, LDAPSearchConstraints constraints)
+			throws LDAPException {
+		chain.nextPostSearchEntry(entry, base, scope, filter, attributes, typesOnly, constraints);
+
+	}
+
+	@Override
+	public void postSearchComplete(PostSearchCompleteInterceptorChain chain, DistinguishedName base, Int scope,
+			Filter filter, ArrayList<Attribute> attributes, Bool typesOnly, LDAPSearchConstraints constraints)
+			throws LDAPException {
+		chain.nextPostSearchComplete(base, scope, filter, attributes, typesOnly, constraints);
+
+	}
+
+	@Override
+	public void shutdown() {
+		
+
+	}
+
+}
diff --git a/src/main/java/net/sourceforge/myvd/inserts/setrdn/SetRDN.java b/src/main/java/net/sourceforge/myvd/inserts/setrdn/SetRDN.java
index f04d66a..10e47ea 100644
--- a/src/main/java/net/sourceforge/myvd/inserts/setrdn/SetRDN.java
+++ b/src/main/java/net/sourceforge/myvd/inserts/setrdn/SetRDN.java
@@ -16,6 +16,7 @@
 
 package net.sourceforge.myvd.inserts.setrdn;
 
+import static org.apache.directory.ldap.client.api.search.FilterBuilder.*;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -24,6 +25,7 @@
 import java.util.StringTokenizer;
 import java.util.Vector;
 
+import org.apache.directory.ldap.client.api.search.FilterBuilder;
 import org.apache.logging.log4j.Logger;
 
 import com.novell.ldap.LDAPAttribute;
@@ -275,10 +277,18 @@ private void setExternalDN(Entry entry) {
 		
 		DN dn = new DN(entry.getEntry().getDN());
 		Vector<RDN> rdns = dn.getRDNs();
-		if (rdns.size() == 0 || ! rdns.get(0).getType().equalsIgnoreCase(this.internalRDN)) {
+		if (rdns.size() == 0) {
+			return;
+		} else if (this.internalRDN.contains("+")) {
+		
+			//for now do nothing
+			
+			
+		} else if (! rdns.get(0).getType().equalsIgnoreCase(this.internalRDN)) {
 			return;
 		}
 		
+		
 		String dnlower = entry.getEntry().getDN().toLowerCase();
 		String strdn = null;//this.in2out.get(dnlower);
 		
@@ -373,7 +383,22 @@ private String getExternalAttrDN(String internalDN,InterceptorChain chain) throw
 		attributes.add(new Attribute(this.objectClass));
 		
 		StringBuffer b = new StringBuffer();
-		b.append("(&(objectClass=").append(this.objectClass).append(")(").append(internalRDNName).append('=').append(internalRDNVal).append("))");
+		
+		if (this.internalRDN.contains("+")) {
+			StringTokenizer toker = new StringTokenizer(internalRDNName + "=" + internalRDNVal,"+");
+			FilterBuilder[] matchFilters = new FilterBuilder[toker.countTokens() + 1];
+			
+			for (int i=0;i<matchFilters.length-1;i++) {
+				String comp = toker.nextToken();
+				matchFilters[i] = FilterBuilder.equal(comp.substring(0,comp.indexOf('=')),comp.substring(comp.indexOf('=') + 1) );
+			}
+			
+			matchFilters[matchFilters.length - 1] = FilterBuilder.equal("objectClass", this.objectClass);
+			
+			b.append(FilterBuilder.and(matchFilters).toString());
+		} else {
+			b.append("(&(objectClass=").append(this.objectClass).append(")(").append(internalRDNName).append('=').append(internalRDNVal).append("))");
+		}
 		//b.append('(').append(this.externalRDN).append('=').append(externalRDNs.get(0).getValue()).append(')');
 		Filter filter = new Filter(b.toString());
 		
@@ -468,21 +493,51 @@ private String getInternalAttrDN(String externalDN,InterceptorChain chain) throw
 			return externalDN;
 		}
 		
-		String val = entry.getEntry().getAttribute(this.internalRDN).getStringValue();
 		
-		DN newInternal = new DN();
-		b.setLength(0);
-		b.append(this.internalRDN).append('=').append(val);
-		RDN rdn = new RDN(b.toString());
-		
-		newInternal.addRDN(rdn);
+		RDN rdn;
 		
-		for (int i=1;i<rdns.size();i++) {
-			newInternal.addRDNToBack((RDN) rdns.get(i));
+		if (this.internalRDN.contains("+")) {
+			StringTokenizer toker = new StringTokenizer(this.internalRDN,"+",false);
+			String val = "";
+			while (toker.hasMoreTokens()) {
+				String comp = toker.nextToken();
+				val += comp + "=" + entry.getEntry().getAttribute(comp).getStringValue() + "+";
+				
+			}
+			val = val.substring(0,val.length()-1);
+			
+			DN newInternal = new DN();
+			
+			
+			//newInternal.addRDN(rdn);
+			
+			for (int i=1;i<rdns.size();i++) {
+				newInternal.addRDNToBack((RDN) rdns.get(i));
+			}
+			String finalDN = val + "," + newInternal.toString();
+			return finalDN;
+		} else {
+			String val = entry.getEntry().getAttribute(this.internalRDN).getStringValue();
+			
+			b.setLength(0);
+			b.append(this.internalRDN).append('=').append(val);
+			rdn = new RDN(b.toString());
+			
+			DN newInternal = new DN();
+			
+			
+			newInternal.addRDN(rdn);
+			
+			for (int i=1;i<rdns.size();i++) {
+				newInternal.addRDNToBack((RDN) rdns.get(i));
+			}
+			
+			this.out2in.put(externalDN.toLowerCase() , newInternal.toString().toLowerCase());
+			return newInternal.toString();
 		}
 		
-		this.out2in.put(externalDN.toLowerCase() , newInternal.toString().toLowerCase());
-		return newInternal.toString();
+		
+		
 		
 	}
 	
@@ -516,11 +571,13 @@ private DN getInternalDN(DN externalDN,InterceptorChain chain,LDAPEntry toadd) t
 		}
 		
 		String val = "";
+		DN internalDN = new DN();
+		RDN rdn = new RDN();
 		
 		if (toadd == null) {
 			ArrayList<Attribute> attributes = new ArrayList<Attribute>();
-			attributes.add(new Attribute(this.internalRDN));
-			attributes.add(new Attribute(this.objectClass));
+			//attributes.add(new Attribute(this.internalRDN));
+			//attributes.add(new Attribute(this.objectClass));
 			
 			StringBuffer b = new StringBuffer();
 			b.append("(&(objectClass=").append(this.objectClass).append(")(").append(this.externalRDN).append('=').append(externalRDNs.get(0).getValue()).append("))");
@@ -543,15 +600,31 @@ private DN getInternalDN(DN externalDN,InterceptorChain chain,LDAPEntry toadd) t
 				return externalDN;
 			}
 			
-			val = entry.getEntry().getAttribute(this.internalRDN).getStringValue();
+			
+			if (this.internalRDN.contains("+")) {
+				StringTokenizer toker = new StringTokenizer(this.internalRDN,"+",false);
+				while (toker.hasMoreTokens()) {
+					String comp = toker.nextToken();
+					val += comp + "=" + entry.getEntry().getAttribute(comp).getStringValue() + "+";
+					
+				}
+				val = val.substring(0,val.length()-1);
+				rdn = new RDN(val);
+				
+			} else {
+				val = entry.getEntry().getAttribute(this.internalRDN).getStringValue();
+				rdn.add(this.internalRDN, val, val);
+			}
+			
+			
 
 		} else {
 			val = toadd.getAttribute(this.internalRDN).getStringValue();
+			rdn.add(this.internalRDN, val, val);
 		}
 		
-		DN internalDN = new DN();
-		RDN rdn = new RDN();
-		rdn.add(this.internalRDN, val, val);
+		
+		
 		internalDN.addRDN(rdn);
 		for (int i=1,m=externalRDNs.size();i<m;i++) {
 			internalDN.addRDNToBack(externalRDNs.get(i));
diff --git a/src/test/java/net/sourceforge/myvd/test/setrdn/SetRDNAD.java b/src/test/java/net/sourceforge/myvd/test/setrdn/SetRDNAD.java
index 15f18db..66e1f52 100644
--- a/src/test/java/net/sourceforge/myvd/test/setrdn/SetRDNAD.java
+++ b/src/test/java/net/sourceforge/myvd/test/setrdn/SetRDNAD.java
@@ -337,12 +337,12 @@ public void testBaseSearch() throws LDAPException {
 		attribs.add(new LDAPAttribute("userPassword", "secret"));
 
 		// attribs.add(new LDAPAttribute("globalTestAttrib","globalTestVal"));
-		LDAPEntry entry2 = new LDAPEntry("cn=Users\\ Test3,cn=users,dc=ad,dc=com", attribs);
+		LDAPEntry entry2 = new LDAPEntry("uid=tuser003,cn=users,dc=ad,dc=com", attribs);
 
 		LDAPConnection con = new LDAPConnection();
 		con.connect("localhost", 50983);
 		// con.bind(3,"cn=admin,o=mycompany","manager".getBytes());
-		LDAPSearchResults res = con.search("cn=Users\\ Test3,cn=users,dc=ad,dc=com", 0, "(objectClass=*)",
+		LDAPSearchResults res = con.search("uid=tuser003,cn=users,dc=ad,dc=com", 0, "(objectClass=*)",
 				new String[0], false);
 
 		/*
diff --git a/src/test/java/net/sourceforge/myvd/test/setrdn/SetRDNMutlValueRDN.java b/src/test/java/net/sourceforge/myvd/test/setrdn/SetRDNMutlValueRDN.java
new file mode 100644
index 0000000..37f0b02
--- /dev/null
+++ b/src/test/java/net/sourceforge/myvd/test/setrdn/SetRDNMutlValueRDN.java
@@ -0,0 +1,476 @@
+/*
+ * Copyright 2008 Marc Boorshtein 
+ * 
+ * Licensed 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 net.sourceforge.myvd.test.setrdn;
+
+import com.novell.ldap.LDAPAttribute;
+import com.novell.ldap.LDAPAttributeSet;
+import com.novell.ldap.LDAPConnection;
+import com.novell.ldap.LDAPEntry;
+import com.novell.ldap.LDAPException;
+import com.novell.ldap.LDAPSearchResults;
+
+import net.sourceforge.myvd.test.util.OpenLDAPUtils;
+import net.sourceforge.myvd.test.util.StartMyVD;
+import net.sourceforge.myvd.test.util.StartOpenLDAP;
+import net.sourceforge.myvd.test.util.Util;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.BeforeClass;
+import org.junit.AfterClass;
+import static org.junit.Assert.*;
+
+public class SetRDNMutlValueRDN {
+
+	private static StartOpenLDAP externalServer;
+	private static StartMyVD server;
+	private static StartOpenLDAP adServer;
+
+	@BeforeClass
+	public static void setUp() throws Exception {
+		OpenLDAPUtils.killAllOpenLDAPS();
+		externalServer = new StartOpenLDAP();
+		externalServer.startServer(System.getenv("PROJ_DIR") + "/test/ExternalUsers", 12983,
+				"cn=admin,ou=external,dc=domain,dc=com", "manager");
+
+		adServer = new StartOpenLDAP();
+		adServer.startServer(System.getenv("PROJ_DIR") + "/test/TestAD2", 13983, "cn=admin,dc=test,dc=mydomain,dc=com",
+				"manager");
+
+		server = new StartMyVD();
+		server.startServer(System.getenv("PROJ_DIR") + "/test/TestServer/setrdnmulti.props", 50983);
+	}
+
+	@Test
+	public void testStartup() {
+		// do nothing
+	}
+
+	@Test
+	public void testUidSearch() throws LDAPException {
+
+		LDAPAttributeSet attribs = new LDAPAttributeSet();
+		attribs.add(new LDAPAttribute("objectClass", "inetOrgPerson"));
+		// attribs.getAttribute("objectClass").addValue("customPerson");
+		attribs.add(new LDAPAttribute("cn", "Test User"));
+		attribs.add(new LDAPAttribute("sn", "User"));
+		attribs.add(new LDAPAttribute("givenName", "Test"));
+		// attribs.add(new LDAPAttribute("testAttrib", "testVal"));
+		attribs.add(new LDAPAttribute("uid", "testmultiuser"));
+		
+
+		// attribs.add(new LDAPAttribute("globalTestAttrib","globalTestVal"));
+		LDAPEntry entry2 = new LDAPEntry("uid=testmultiuser,cn=users2,dc=ad,dc=com", attribs);
+
+		LDAPConnection con = new LDAPConnection();
+		con.connect("localhost", 50983);
+		// con.bind(3,"cn=admin,o=mycompany","manager".getBytes());
+		LDAPSearchResults res = con.search("cn=users2,dc=ad,dc=com", 2, "(uid=testmultiuser)", new String[0], false);
+
+		int size = 0;
+
+		while (res.hasMore()) {
+			LDAPEntry fromDir = res.next();
+			LDAPEntry controlEntry = null;// control.get(fromDir.getEntry().getDN());
+
+			if (size == 0) {
+				controlEntry = entry2;
+			} else if (size == 1) {
+				controlEntry = null;
+			} else {
+				controlEntry = null;
+			}
+
+			if (controlEntry == null) {
+				fail("Entry " + fromDir.getDN() + " should not be returned");
+				return;
+			}
+
+			if (!Util.compareEntry(fromDir, controlEntry)) {
+				fail("The entry was not correct : " + fromDir.toString());
+				return;
+			}
+
+			size++;
+		}
+
+		if (size != 1) {
+			fail("Not the correct number of entries : " + size);
+		}
+
+		con.disconnect();
+
+	}
+
+	@Test
+	public void testOCSearch() throws LDAPException {
+
+		LDAPAttributeSet attribs = new LDAPAttributeSet();
+		attribs.add(new LDAPAttribute("objectClass", "inetOrgPerson"));
+		// attribs.getAttribute("objectClass").addValue("customPerson");
+		attribs.add(new LDAPAttribute("cn", "Test User"));
+		attribs.add(new LDAPAttribute("sn", "User"));
+		attribs.add(new LDAPAttribute("givenName", "Test"));
+		// attribs.add(new LDAPAttribute("testAttrib", "testVal"));
+		attribs.add(new LDAPAttribute("uid", "testmultiuser"));
+		
+
+		// attribs.add(new LDAPAttribute("globalTestAttrib","globalTestVal"));
+		LDAPEntry entry2 = new LDAPEntry("uid=testmultiuser,cn=users2,dc=ad,dc=com", attribs);
+
+		LDAPConnection con = new LDAPConnection();
+		con.connect("localhost", 50983);
+		// con.bind(3,"cn=admin,o=mycompany","manager".getBytes());
+		LDAPSearchResults res = con.search("cn=users2,dc=ad,dc=com", 1, "(objectClass=*)",
+				new String[] { "objectClass", "hasSubordinates" }, false);
+
+		int size = 3;
+
+		while (res.hasMore()) {
+			LDAPEntry fromDir = res.next();
+
+			size++;
+		}
+
+		if (size != 7) {
+			fail("Not the correct number of entries : " + size);
+		}
+
+		con.disconnect();
+
+	}
+
+	@Test
+	public void testUidSearchOnlyUID() throws LDAPException {
+
+		LDAPAttributeSet attribs = new LDAPAttributeSet();
+		attribs.add(new LDAPAttribute("objectClass", "inetOrgPerson"));
+		// attribs.getAttribute("objectClass").addValue("customPerson");
+		attribs.add(new LDAPAttribute("cn", "Test User"));
+		attribs.add(new LDAPAttribute("sn", "User"));
+		attribs.add(new LDAPAttribute("givenName", "Test"));
+		// attribs.add(new LDAPAttribute("testAttrib", "testVal"));
+		attribs.add(new LDAPAttribute("uid", "testmultiuser"));
+		
+
+		// attribs.add(new LDAPAttribute("globalTestAttrib","globalTestVal"));
+		LDAPEntry entry2 = new LDAPEntry("uid=testmultiuser,cn=users2,dc=ad,dc=com", attribs);
+
+		LDAPConnection con = new LDAPConnection();
+		con.connect("localhost", 50983);
+		// con.bind(3,"cn=admin,o=mycompany","manager".getBytes());
+		LDAPSearchResults res = con.search("cn=users2,dc=ad,dc=com", 2, "(uid=testmultiuser)", new String[] { "uid" }, false);
+
+		int size = 0;
+
+		while (res.hasMore()) {
+			LDAPEntry fromDir = res.next();
+			LDAPEntry controlEntry = null;// control.get(fromDir.getEntry().getDN());
+
+			if (size == 0) {
+				controlEntry = entry2;
+			} else if (size == 1) {
+				controlEntry = null;
+			} else {
+				controlEntry = null;
+			}
+
+			if (controlEntry == null) {
+				fail("Entry " + fromDir.getDN() + " should not be returned");
+				return;
+			}
+
+			if (!Util.compareEntry(fromDir, controlEntry)) {
+				fail("The entry was not correct : " + fromDir.toString());
+				return;
+			}
+
+			size++;
+		}
+
+		if (size != 1) {
+			fail("Not the correct number of entries : " + size);
+		}
+
+		con.disconnect();
+
+	}
+
+	
+
+	@Test
+	public void testEntry() throws LDAPException {
+
+		LDAPAttributeSet attribs = new LDAPAttributeSet();
+		attribs.add(new LDAPAttribute("objectClass", "inetOrgPerson"));
+		// attribs.getAttribute("objectClass").addValue("customPerson");
+		attribs.add(new LDAPAttribute("cn", "Test User"));
+		attribs.add(new LDAPAttribute("sn", "User"));
+		attribs.add(new LDAPAttribute("givenName", "Test"));
+		// attribs.add(new LDAPAttribute("testAttrib", "testVal"));
+		attribs.add(new LDAPAttribute("uid", "testmultiuser"));
+		
+
+		// attribs.add(new LDAPAttribute("globalTestAttrib","globalTestVal"));
+		LDAPEntry entry2 = new LDAPEntry("uid=testmultiuser,cn=users2,dc=ad,dc=com", attribs);
+
+		LDAPConnection con = new LDAPConnection();
+		con.connect("localhost", 50983);
+		// con.bind(3,"cn=admin,o=mycompany","manager".getBytes());
+		LDAPSearchResults res = con.search("cn=users2,dc=ad,dc=com", 2, "(cn=Test User)", new String[0], false);
+
+		int size = 0;
+
+		while (res.hasMore()) {
+			LDAPEntry fromDir = res.next();
+			LDAPEntry controlEntry = null;// control.get(fromDir.getEntry().getDN());
+
+			if (size == 0) {
+				controlEntry = entry2;
+			} else if (size == 1) {
+				controlEntry = null;
+			} else {
+				controlEntry = null;
+			}
+
+			if (controlEntry == null) {
+				fail("Entry " + fromDir.getDN() + " should not be returned");
+				return;
+			}
+
+			if (!Util.compareEntry(fromDir, controlEntry)) {
+				fail("The entry was not correct : " + fromDir.toString());
+				return;
+			}
+
+			size++;
+		}
+
+		if (size != 1) {
+			fail("Not the correct number of entries : " + size);
+		}
+
+		con.disconnect();
+
+	}
+
+	@Test
+	public void testAnonBind() throws LDAPException {
+		LDAPConnection con = new LDAPConnection();
+		con.connect("localhost", 50983);
+		con.bind(3, "anonymous", new byte[0]);
+	}
+
+	@Test
+	public void testBaseSearch() throws LDAPException {
+
+		LDAPAttributeSet attribs = new LDAPAttributeSet();
+		attribs.add(new LDAPAttribute("objectClass", "inetOrgPerson"));
+		// attribs.getAttribute("objectClass").addValue("customPerson");
+		attribs.add(new LDAPAttribute("cn", "Test User"));
+		attribs.add(new LDAPAttribute("sn", "User"));
+		attribs.add(new LDAPAttribute("givenName", "Test"));
+		// attribs.add(new LDAPAttribute("testAttrib", "testVal"));
+		attribs.add(new LDAPAttribute("uid", "testmultiuser"));
+		
+
+		// attribs.add(new LDAPAttribute("globalTestAttrib","globalTestVal"));
+		LDAPEntry entry2 = new LDAPEntry("uid=testmultiuser,cn=users2,dc=ad,dc=com", attribs);
+
+		LDAPConnection con = new LDAPConnection();
+		con.connect("localhost", 50983);
+		// con.bind(3,"cn=admin,o=mycompany","manager".getBytes());
+		LDAPSearchResults res = con.search("uid=testmultiuser,cn=users2,dc=ad,dc=com", 0, "(objectClass=*)",
+				new String[0], false);
+
+		/*
+		 * if (results.size() != 3) { fail("incorrect number of result sets : "
+		 * + results.size()); return; }
+		 */
+
+		int size = 0;
+
+		while (res.hasMore()) {
+			LDAPEntry fromDir = res.next();
+			LDAPEntry controlEntry = null;// control.get(fromDir.getEntry().getDN());
+
+			if (size == 0) {
+				controlEntry = entry2;
+			} else if (size == 1) {
+				controlEntry = null;
+			} else {
+				controlEntry = null;
+			}
+
+			if (controlEntry == null) {
+				fail("Entry " + fromDir.getDN() + " should not be returned");
+				return;
+			}
+
+			if (!Util.compareEntry(fromDir, controlEntry)) {
+				fail("The entry was not correct : " + fromDir.toString());
+				return;
+			}
+
+			size++;
+		}
+
+		if (size != 1) {
+			fail("Not the correct number of entries : " + size);
+		}
+
+		con.disconnect();
+	}
+
+	@Test
+	public void testGroupMemberBase() throws LDAPException {
+
+		LDAPAttributeSet attribs = new LDAPAttributeSet();
+		attribs.add(new LDAPAttribute("objectClass", "groupOfUniqueNames"));
+		// attribs.getAttribute("objectClass").addValue("customPerson");
+		attribs.add(new LDAPAttribute("cn", "UNIX SUDO Usersx"));
+		attribs.add(new LDAPAttribute("uniqueMember", "uid=testmultiuser,cn=users2,dc=ad,dc=com"));
+		// attribs.add(new LDAPAttribute("testAttrib", "testVal"));
+
+		// attribs.add(new LDAPAttribute("globalTestAttrib","globalTestVal"));
+		LDAPEntry entry2 = new LDAPEntry("cn=UNIX SUDO Usersx,cn=users2,dc=ad,dc=com", attribs);
+
+		LDAPConnection con = new LDAPConnection();
+		con.connect("localhost", 50983);
+		// con.bind(3,"cn=admin,o=mycompany","manager".getBytes());
+		LDAPSearchResults res = con.search("cn=UNIX SUDO Usersx,cn=users2,dc=ad,dc=com", 0, "(objectClass=*)",
+				new String[0], false);
+
+		/*
+		 * if (results.size() != 3) { fail("incorrect number of result sets : "
+		 * + results.size()); return; }
+		 */
+
+		int size = 0;
+
+		while (res.hasMore()) {
+			LDAPEntry fromDir = res.next();
+			LDAPEntry controlEntry = null;// control.get(fromDir.getEntry().getDN());
+
+			if (size == 0) {
+				controlEntry = entry2;
+			} else if (size == 1) {
+				controlEntry = null;
+			} else {
+				controlEntry = null;
+			}
+
+			if (controlEntry == null) {
+				fail("Entry " + fromDir.getDN() + " should not be returned");
+				return;
+			}
+
+			if (!Util.compareEntry(fromDir, controlEntry)) {
+				fail("The entry was not correct : " + fromDir.toString());
+				return;
+			}
+
+			size++;
+		}
+
+		if (size != 1) {
+			fail("Not the correct number of entries : " + size);
+		}
+
+		con.disconnect();
+	}
+
+	@Test
+	public void testGroupMemberFilter() throws LDAPException {
+
+		LDAPAttributeSet attribs = new LDAPAttributeSet();
+		attribs.add(new LDAPAttribute("objectClass", "groupOfUniqueNames"));
+		// attribs.getAttribute("objectClass").addValue("customPerson");
+		attribs.add(new LDAPAttribute("cn", "UNIX Usersx"));
+		LDAPAttribute attr = new LDAPAttribute("uniqueMember", "uid=testmultiuser,cn=users2,dc=ad,dc=com");
+		attr.addValue("uid=testmultiuserx,cn=users2,dc=ad,dc=com");
+
+		attribs.add(attr);
+
+		// attribs.add(new LDAPAttribute("testAttrib", "testVal"));
+
+		// attribs.add(new LDAPAttribute("globalTestAttrib","globalTestVal"));
+		LDAPEntry entry3 = new LDAPEntry("cn=UNIX Usersx,cn=users2,dc=ad,dc=com", attribs);
+
+		attribs = new LDAPAttributeSet();
+		attribs.add(new LDAPAttribute("objectClass", "groupOfUniqueNames"));
+		// attribs.getAttribute("objectClass").addValue("customPerson");
+		attribs.add(new LDAPAttribute("cn", "UNIX SUDO Usersx"));
+		attribs.add(new LDAPAttribute("uniqueMember", "uid=testmultiuser,cn=users2,dc=ad,dc=com"));
+		// attribs.add(new LDAPAttribute("testAttrib", "testVal"));
+
+		// attribs.add(new LDAPAttribute("globalTestAttrib","globalTestVal"));
+		LDAPEntry entry2 = new LDAPEntry("cn=UNIX SUDO Usersx,cn=users2,dc=ad,dc=com", attribs);
+
+		LDAPConnection con = new LDAPConnection();
+		con.connect("localhost", 50983);
+		// con.bind(3,"cn=admin,o=mycompany","manager".getBytes());
+		LDAPSearchResults res = con.search("dc=ad,dc=com", 2, "(uniqueMember=uid=testmultiuser,cn=users2,dc=ad,dc=com)",
+				new String[0], false);
+
+		/*
+		 * if (results.size() != 3) { fail("incorrect number of result sets : "
+		 * + results.size()); return; }
+		 */
+
+		int size = 0;
+
+		while (res.hasMore()) {
+			LDAPEntry fromDir = res.next();
+			LDAPEntry controlEntry = null;// control.get(fromDir.getEntry().getDN());
+
+			if (size == 0) {
+				controlEntry = entry3;
+			} else if (size == 1) {
+				controlEntry = entry2;
+			} else {
+				controlEntry = null;
+			}
+
+			if (controlEntry == null) {
+				fail("Entry " + fromDir.getDN() + " should not be returned");
+				return;
+			}
+
+			if (!Util.compareEntry(fromDir, controlEntry)) {
+				fail("The entry was not correct for " + size + " : " + fromDir.toString() + " / " + controlEntry);
+				return;
+			}
+
+			size++;
+		}
+
+		if (size != 2) {
+			fail("Not the correct number of entries : " + size);
+		}
+
+		con.disconnect();
+	}
+
+	@AfterClass
+	public static void tearDown() throws Exception {
+
+		server.stopServer();
+		externalServer.stopServer();
+		adServer.stopServer();
+	}
+}
diff --git a/test/TestAD/data.ldif b/test/TestAD/data.ldif
index 174144e..388de14 100644
--- a/test/TestAD/data.ldif
+++ b/test/TestAD/data.ldif
@@ -55,3 +55,7 @@ objectClass: group
 cn: Parenthasis (are) in my (cn)
 member: cn=(I) dont (understand) why,cn=users,dc=test,dc=mydomain,dc=com
 
+
+
+
+
diff --git a/test/TestAD2/custom.schema b/test/TestAD2/custom.schema
new file mode 100644
index 0000000..71a17d2
--- /dev/null
+++ b/test/TestAD2/custom.schema
@@ -0,0 +1,29 @@
+attributetype ( 2.16.840.1.113330.3.1.1
+	NAME 'samAccountName'
+	DESC 'AD uid'
+	EQUALITY caseIgnoreMatch
+   SUBSTR caseIgnoreSubstringsMatch
+   SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{256}  )
+	
+
+objectclass  ( 2.16.840.1.333730.3.2.2
+    NAME 'container'
+    DESC 'ad container'
+    SUP top
+    STRUCTURAL
+    MUST ( cn ) )
+
+objectclass  ( 2.16.840.1.333730.3.2.3
+    NAME 'user'
+    DESC 'ad person'
+    SUP inetOrgPerson
+    STRUCTURAL
+    MUST ( samAccountName ) )
+    
+objectclass  ( 2.16.840.1.333730.3.2.4
+    NAME 'group'
+    DESC 'ad group'
+    SUP top
+    STRUCTURAL
+    MUST ( cn )
+    MAY ( member ) )
diff --git a/test/TestAD2/data.ldif b/test/TestAD2/data.ldif
new file mode 100644
index 0000000..2a4ec0b
--- /dev/null
+++ b/test/TestAD2/data.ldif
@@ -0,0 +1,37 @@
+version: 1
+
+dn: dc=test,dc=mydomain,dc=com
+objectClass: domain
+dc: test
+
+
+dn: cn=users2,dc=test,dc=mydomain,dc=com
+objectClass: container
+cn: users2
+
+dn: givenName=Test+sn=User+uid=testmultiuser,cn=users2,dc=test,dc=mydomain,dc=com
+objectClass: user
+givenName: Test
+sn: User
+cn: Test User
+samAccountName: testmultiuser
+
+dn: givenName=Testx+sn=Userx+uid=testmultiuserx,cn=users2,dc=test,dc=mydomain,dc=com
+objectClass: user
+givenName: Testx
+sn: Userx
+cn: Test Userx
+samAccountName: testmultiuserx
+
+
+
+dn: cn=UNIX Usersx,cn=users2,dc=test,dc=mydomain,dc=com
+objectClass: group
+cn: UNIX Usersx
+member: givenName=Testx+sn=Userx+uid=testmultiuserx,cn=users2,dc=test,dc=mydomain,dc=com
+member: givenName=Test+sn=User+uid=testmultiuser,cn=users2,dc=test,dc=mydomain,dc=com
+
+dn: cn=UNIX SUDO Usersx,cn=users2,dc=test,dc=mydomain,dc=com
+objectClass: group
+cn: UNIX SUDO Usersx
+member: givenName=Test+sn=User+uid=testmultiuser,cn=users2,dc=test,dc=mydomain,dc=com
diff --git a/test/TestAD2/domainGroupSearch.ldif b/test/TestAD2/domainGroupSearch.ldif
new file mode 100644
index 0000000..f3cdbb3
--- /dev/null
+++ b/test/TestAD2/domainGroupSearch.ldif
@@ -0,0 +1,7 @@
+version: 1
+
+dn: cn=Domain Users,cn=users,o=ad
+objectClass: group
+cn: Domain Users
+member: cn=Test1 User,cn=users,o=ad
+member: cn=Test2 User,cn=users,o=ad
\ No newline at end of file
diff --git a/test/TestAD2/slapd.conf b/test/TestAD2/slapd.conf
new file mode 100644
index 0000000..133972d
--- /dev/null
+++ b/test/TestAD2/slapd.conf
@@ -0,0 +1,95 @@
+#
+# See slapd.conf(5) for details on configuration options.
+# This file should NOT be world readable.
+#
+include		%SCHEMA_DIR%/schema/core.schema
+include		%SCHEMA_DIR%/schema/cosine.schema
+include		%SCHEMA_DIR%/schema/inetorgperson.schema
+include		%SCHEMA_DIR%/schema/nis.schema
+include		%PROJ_DIR%/test/TestAD2/custom.schema
+
+
+# Allow LDAPv2 client connections.  This is NOT the default.
+allow bind_v2
+
+# Do not enable referrals until AFTER you have a working directory
+# service AND an understanding of referrals.
+#referral	ldap://root.openldap.org
+
+pidfile		%PROJ_DIR%/test/TestAD2/slapd.pid
+argsfile	%PROJ_DIR%/test/TestAD2/slapd.args
+
+# Load dynamic backend modules:
+# modulepath	/usr/sbin/openldap
+# moduleload	back_bdb.la
+# moduleload	back_ldap.la
+# moduleload	back_ldbm.la
+# moduleload	back_passwd.la
+# moduleload	back_shell.la
+
+# The next three lines allow use of TLS for encrypting connections using a
+# dummy test certificate which you can generate by changing to
+# /usr/share/ssl/certs, running "make slapd.pem", and fixing permissions on
+# slapd.pem so that the ldap user or group can read it.  Your client software
+# may balk at self-signed certificates, however.
+# TLSCACertificateFile /usr/share/ssl/certs/ca-bundle.crt
+# TLSCertificateFile /usr/share/ssl/certs/slapd.pem
+# TLSCertificateKeyFile /usr/share/ssl/certs/slapd.pem
+
+# Sample security restrictions
+#	Require integrity protection (prevent hijacking)
+#	Require 112-bit (3DES or better) encryption for updates
+#	Require 63-bit encryption for simple bind
+# security ssf=1 update_ssf=112 simple_bind=64
+
+# Sample access control policy:
+#	Root DSE: allow anyone to read it
+#	Subschema (sub)entry DSE: allow anyone to read it
+#	Other DSEs:
+#		Allow self write access
+#		Allow authenticated users read access
+#		Allow anonymous users to authenticate
+#	Directives needed to implement policy:
+# access to dn.base="" by * read
+# access to dn.base="cn=Subschema" by * read
+# access to *
+#	by self write
+#	by users read
+#	by anonymous auth
+#
+# if no access controls are present, the default policy
+# allows anyone and everyone to read anything but restricts
+# updates to rootdn.  (e.g., "access to * by * read")
+#
+# rootdn can always read and write EVERYTHING!
+
+#######################################################################
+# ldbm and/or bdb database definitions
+#######################################################################
+
+database	mdb
+suffix		"dc=test,dc=mydomain,dc=com"
+rootdn		"cn=admin,dc=test,dc=mydomain,dc=com"
+# Cleartext passwords, especially for the rootdn, should
+# be avoided.  See slappasswd(8) and slapd.conf(5) for details.
+# Use of strong authentication encouraged.
+rootpw		manager
+# rootpw		{crypt}ijFYNcSNctBYg
+
+# The database directory MUST exist prior to running slapd AND 
+# should only be accessible by the slapd and slap tools.
+# Mode 700 recommended.
+directory	%PROJ_DIR%/test/TestAD2/data
+
+# Indices to maintain for this database
+index objectClass                       eq,pres
+index ou,cn,mail,surname,givenname      eq,pres,sub
+index uidNumber,gidNumber,loginShell    eq,pres
+index uid,memberUid                     eq,pres,sub
+index nisMapName,nisMapEntry            eq,pres,sub
+
+# Replicas of this database
+#replogfile /var/lib/ldap/openldap-master-replog
+#replica host=ldap-1.example.com:389 starttls=critical
+#     bindmethod=sasl saslmech=GSSAPI
+#     authcId=host/ldap-master.example.com@EXAMPLE.COM
diff --git a/test/TestServer/setrdn.props b/test/TestServer/setrdn.props
index 3bbec21..509ca37 100644
--- a/test/TestServer/setrdn.props
+++ b/test/TestServer/setrdn.props
@@ -31,7 +31,7 @@ server.ExternalServer.LDAPExternalServer.config.proxyDN=cn=admin,ou=external,dc=
 server.ExternalServer.LDAPExternalServer.config.proxyPass=manager
 
 
-server.AD.chain=dump,SetRDN,objmap,membertrans,mapdn,ldap
+server.AD.chain=SetRDN,dump,objmap,membertrans,mapdn,ldap
 server.AD.nameSpace=dc=ad,dc=com
 server.AD.wieght=15
 
@@ -56,6 +56,8 @@ server.AD.mapdn.config.localBase=dc=ad,dc=com
 server.AD.dump.className=net.sourceforge.myvd.inserts.DumpTransaction
 server.AD.dump.config.logLevel=info
 
+
+
 server.AD.ldap.className=net.sourceforge.myvd.inserts.ldap.LDAPInterceptor
 server.AD.ldap.config.host=localhost
 server.AD.ldap.config.port=13983
diff --git a/test/TestServer/setrdnmulti.props b/test/TestServer/setrdnmulti.props
new file mode 100644
index 0000000..02cd9e0
--- /dev/null
+++ b/test/TestServer/setrdnmulti.props
@@ -0,0 +1,43 @@
+server.listener.port=50983
+server.globalChain=
+#Test global
+
+server.nameSpaces=AD
+
+
+
+server.AD.chain=dump,SetRDN,objmap,membertrans,mapdn,unescape,ldap
+server.AD.nameSpace=dc=ad,dc=com
+server.AD.wieght=15
+
+server.AD.SetRDN.className=net.sourceforge.myvd.inserts.setrdn.SetRDN
+server.AD.SetRDN.config.internalRDN=givenName+sn+uid
+server.AD.SetRDN.config.externalRDN=uid
+server.AD.SetRDN.config.objectClass=inetOrgPerson
+server.AD.SetRDN.config.dnattributes=uniqueMember
+
+server.AD.objmap.className=net.sourceforge.myvd.inserts.mapping.AttributeValueMapper
+server.AD.objmap.config.mapping=objectClass.inetOrgPerson=user,objectClass.groupOfUniqueNames=group
+
+server.AD.membertrans.className=net.sourceforge.myvd.inserts.mapping.AttributeMapper
+server.AD.membertrans.config.mapping=uniqueMember=member,uid=samAccountName
+
+server.AD.mapdn.className=net.sourceforge.myvd.inserts.mapping.DNAttributeMapper
+server.AD.mapdn.config.dnAttribs=member
+server.AD.mapdn.config.urlAttribs=
+server.AD.mapdn.config.remoteBase=dc=test,dc=mydomain,dc=com
+server.AD.mapdn.config.localBase=dc=ad,dc=com
+
+server.AD.dump.className=net.sourceforge.myvd.inserts.DumpTransaction
+server.AD.dump.config.logLevel=info
+
+server.AD.unescape.className=net.sourceforge.myvd.inserts.mapping.ClearMultiValueRDNEscapesFilter
+
+
+server.AD.ldap.className=net.sourceforge.myvd.inserts.ldap.LDAPInterceptor
+server.AD.ldap.config.host=localhost
+server.AD.ldap.config.port=13983
+server.AD.ldap.config.remoteBase=dc=test,dc=mydomain,dc=com
+server.AD.ldap.config.proxyDN=cn=admin,dc=test,dc=mydomain,dc=com
+server.AD.ldap.config.proxyPass=manager
+