From commits-return-26569-apmail-directory-commits-archive=directory.apache.org@directory.apache.org Thu Jul 15 10:05:16 2010 Return-Path: Delivered-To: apmail-directory-commits-archive@www.apache.org Received: (qmail 21943 invoked from network); 15 Jul 2010 10:05:15 -0000 Received: from unknown (HELO mail.apache.org) (140.211.11.3) by 140.211.11.9 with SMTP; 15 Jul 2010 10:05:15 -0000 Received: (qmail 10732 invoked by uid 500); 15 Jul 2010 10:05:15 -0000 Delivered-To: apmail-directory-commits-archive@directory.apache.org Received: (qmail 10652 invoked by uid 500); 15 Jul 2010 10:05:14 -0000 Mailing-List: contact commits-help@directory.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@directory.apache.org Delivered-To: mailing list commits@directory.apache.org Received: (qmail 10592 invoked by uid 99); 15 Jul 2010 10:05:14 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 15 Jul 2010 10:05:14 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=10.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 15 Jul 2010 10:05:03 +0000 Received: by eris.apache.org (Postfix, from userid 65534) id 54EA623889E0; Thu, 15 Jul 2010 10:04:09 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r964361 [2/5] - in /directory/shared/trunk: ldap-schema-manager-tests/ ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/ ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/schema/syntaxCheck... Date: Thu, 15 Jul 2010 10:04:08 -0000 To: commits@directory.apache.org From: elecharny@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20100715100409.54EA623889E0@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Added: directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/ProtectedItem_RestrictedByTest.java URL: http://svn.apache.org/viewvc/directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/ProtectedItem_RestrictedByTest.java?rev=964361&view=auto ============================================================================== --- directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/ProtectedItem_RestrictedByTest.java (added) +++ directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/ProtectedItem_RestrictedByTest.java Thu Jul 15 10:04:06 2010 @@ -0,0 +1,146 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ +package org.apache.directory.shared.ldap.aci; + + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; + +import java.util.HashSet; +import java.util.Set; + +import org.apache.directory.junit.tools.Concurrent; +import org.apache.directory.junit.tools.ConcurrentJunitRunner; +import org.apache.directory.shared.ldap.aci.protectedItem.RestrictedByElem; +import org.apache.directory.shared.ldap.aci.protectedItem.RestrictedByItem; +import org.apache.directory.shared.ldap.schema.AttributeType; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + + +/** + * Unit tests class ProtectedItem.RestrictedBy. + * + * @author Apache Directory Project + */ +@RunWith(ConcurrentJunitRunner.class) +@Concurrent() +public class ProtectedItem_RestrictedByTest +{ + RestrictedByItem restrictedByA; + RestrictedByItem restrictedByACopy; + RestrictedByItem restrictedByB; + RestrictedByItem restrictedByC; + + + /** + * Initialize name instances + */ + @Before + public void initNames() throws Exception + { + RestrictedByElem rbiA = new RestrictedByElem( new AttributeType( "aa" ), new AttributeType( "aa" ) ); + RestrictedByElem rbiB = new RestrictedByElem( new AttributeType( "bb" ), new AttributeType( "bb" ) ); + RestrictedByElem rbiC = new RestrictedByElem( new AttributeType( "cc" ), new AttributeType( "cc" ) ); + RestrictedByElem rbiD = new RestrictedByElem( new AttributeType( "dd" ), new AttributeType( "dd" ) ); + + Set colA = new HashSet(); + colA.add( rbiA ); + colA.add( rbiB ); + colA.add( rbiC ); + Set colB = new HashSet(); + colB.add( rbiA ); + colB.add( rbiB ); + colB.add( rbiC ); + Set colC = new HashSet(); + colC.add( rbiB ); + colC.add( rbiC ); + colC.add( rbiD ); + + restrictedByA = new RestrictedByItem( colA ); + restrictedByACopy = new RestrictedByItem( colA ); + restrictedByB = new RestrictedByItem( colB ); + restrictedByC = new RestrictedByItem( colC ); + } + + + @Test + public void testEqualsNull() throws Exception + { + assertFalse( restrictedByA.equals( null ) ); + } + + + @Test + public void testEqualsReflexive() throws Exception + { + assertEquals( restrictedByA, restrictedByA ); + } + + + @Test + public void testHashCodeReflexive() throws Exception + { + assertEquals( restrictedByA.hashCode(), restrictedByA.hashCode() ); + } + + + @Test + public void testEqualsSymmetric() throws Exception + { + assertEquals( restrictedByA, restrictedByACopy ); + assertEquals( restrictedByACopy, restrictedByA ); + } + + + @Test + public void testHashCodeSymmetric() throws Exception + { + assertEquals( restrictedByA.hashCode(), restrictedByACopy.hashCode() ); + assertEquals( restrictedByACopy.hashCode(), restrictedByA.hashCode() ); + } + + + @Test + public void testEqualsTransitive() throws Exception + { + assertEquals( restrictedByA, restrictedByACopy ); + assertEquals( restrictedByACopy, restrictedByB ); + assertEquals( restrictedByA, restrictedByB ); + } + + + @Test + public void testHashCodeTransitive() throws Exception + { + assertEquals( restrictedByA.hashCode(), restrictedByACopy.hashCode() ); + assertEquals( restrictedByACopy.hashCode(), restrictedByB.hashCode() ); + assertEquals( restrictedByA.hashCode(), restrictedByB.hashCode() ); + } + + + @Test + public void testNotEqualDiffValue() throws Exception + { + assertFalse( restrictedByA.equals( restrictedByC ) ); + assertFalse( restrictedByC.equals( restrictedByA ) ); + } +} Added: directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/ProtectedItem_SelfValueTest.java URL: http://svn.apache.org/viewvc/directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/ProtectedItem_SelfValueTest.java?rev=964361&view=auto ============================================================================== --- directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/ProtectedItem_SelfValueTest.java (added) +++ directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/ProtectedItem_SelfValueTest.java Thu Jul 15 10:04:06 2010 @@ -0,0 +1,140 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ +package org.apache.directory.shared.ldap.aci; + + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; + +import java.util.HashSet; +import java.util.Set; + +import org.apache.directory.junit.tools.Concurrent; +import org.apache.directory.junit.tools.ConcurrentJunitRunner; +import org.apache.directory.shared.ldap.aci.protectedItem.SelfValueItem; +import org.apache.directory.shared.ldap.schema.AttributeType; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + + +/** + * Unit tests class ProtectedItem.SelfValue. + * + * @author Apache Directory Project + */ +@RunWith(ConcurrentJunitRunner.class) +@Concurrent() +public class ProtectedItem_SelfValueTest +{ + SelfValueItem selfValueA; + SelfValueItem selfValueACopy; + SelfValueItem selfValueB; + SelfValueItem selfValueC; + + + /** + * Initialize name instances + */ + @Before + public void initNames() throws Exception + { + Set colA = new HashSet(); + colA.add( new AttributeType( "aa" ) ); + colA.add( new AttributeType( "bb" ) ); + colA.add( new AttributeType( "cc" ) ); + Set colB = new HashSet(); + colB.add( new AttributeType( "aa" ) ); + colB.add( new AttributeType( "bb" ) ); + colB.add( new AttributeType( "cc" ) ); + Set colC = new HashSet(); + colC.add( new AttributeType( "bb" ) ); + colC.add( new AttributeType( "cc" ) ); + colC.add( new AttributeType( "dd" ) ); + + selfValueA = new SelfValueItem( colA ); + selfValueACopy = new SelfValueItem( colA ); + selfValueB = new SelfValueItem( colB ); + selfValueC = new SelfValueItem( colC ); + } + + + @Test + public void testEqualsNull() throws Exception + { + assertFalse( selfValueA.equals( null ) ); + } + + + @Test + public void testEqualsReflexive() throws Exception + { + assertEquals( selfValueA, selfValueA ); + } + + + @Test + public void testHashCodeReflexive() throws Exception + { + assertEquals( selfValueA.hashCode(), selfValueA.hashCode() ); + } + + + @Test + public void testEqualsSymmetric() throws Exception + { + assertEquals( selfValueA, selfValueACopy ); + assertEquals( selfValueACopy, selfValueA ); + } + + + @Test + public void testHashCodeSymmetric() throws Exception + { + assertEquals( selfValueA.hashCode(), selfValueACopy.hashCode() ); + assertEquals( selfValueACopy.hashCode(), selfValueA.hashCode() ); + } + + + @Test + public void testEqualsTransitive() throws Exception + { + assertEquals( selfValueA, selfValueACopy ); + assertEquals( selfValueACopy, selfValueB ); + assertEquals( selfValueA, selfValueB ); + } + + + @Test + public void testHashCodeTransitive() throws Exception + { + assertEquals( selfValueA.hashCode(), selfValueACopy.hashCode() ); + assertEquals( selfValueACopy.hashCode(), selfValueB.hashCode() ); + assertEquals( selfValueA.hashCode(), selfValueB.hashCode() ); + } + + + @Test + public void testNotEqualDiffValue() throws Exception + { + assertFalse( selfValueA.equals( selfValueC ) ); + assertFalse( selfValueC.equals( selfValueA ) ); + } +} Added: directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/UserClass_NameTest.java URL: http://svn.apache.org/viewvc/directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/UserClass_NameTest.java?rev=964361&view=auto ============================================================================== --- directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/UserClass_NameTest.java (added) +++ directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/UserClass_NameTest.java Thu Jul 15 10:04:06 2010 @@ -0,0 +1,144 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ +package org.apache.directory.shared.ldap.aci; + + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; + +import java.util.HashSet; +import java.util.Set; + +import org.apache.directory.junit.tools.Concurrent; +import org.apache.directory.junit.tools.ConcurrentJunitRunner; +import org.apache.directory.shared.ldap.aci.UserClass.Name; +import org.apache.directory.shared.ldap.exception.LdapInvalidDnException; +import org.apache.directory.shared.ldap.name.DN; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + + +/** + * Unit tests class UserClass.Name. + * + * @author Apache Directory Project + */ +@RunWith(ConcurrentJunitRunner.class) +@Concurrent() +public class UserClass_NameTest +{ + private Name nameA; + private Name nameACopy; + private Name nameB; + private Name nameC; + + + /** + * Initialize name instances + */ + @Before + public void initNames() throws LdapInvalidDnException + { + Set dnSetA = new HashSet(); + dnSetA.add( new DN( "a=aa" ) ); + dnSetA.add( new DN( "b=bb" ) ); + + Set dnSetB = new HashSet(); + dnSetB.add( new DN( "b=bb" ) ); + dnSetB.add( new DN( "a=aa" ) ); + + Set dnSetC = new HashSet(); + dnSetC.add( new DN( "a=aa" ) ); + dnSetC.add( new DN( "b=bb" ) ); + + Set dnSetD = new HashSet(); + dnSetD.add( new DN( "b=bb" ) ); + dnSetD.add( new DN( "c=cc" ) ); + + nameA = new Name( dnSetA ); + nameACopy = new Name( dnSetB ); + nameB = new Name( dnSetC ); + nameC = new Name( dnSetD ); + } + + + @Test + public void testEqualsNull() throws Exception + { + assertFalse( nameA.equals( null ) ); + } + + + @Test + public void testEqualsReflexive() throws Exception + { + assertEquals( nameA, nameA ); + } + + + @Test + public void testHashCodeReflexive() throws Exception + { + assertEquals( nameA.hashCode(), nameA.hashCode() ); + } + + + @Test + public void testEqualsSymmetric() throws Exception + { + assertEquals( nameA, nameACopy ); + assertEquals( nameACopy, nameA ); + } + + + @Test + public void testHashCodeSymmetric() throws Exception + { + assertEquals( nameA.hashCode(), nameACopy.hashCode() ); + assertEquals( nameACopy.hashCode(), nameA.hashCode() ); + } + + + @Test + public void testEqualsTransitive() throws Exception + { + assertEquals( nameA, nameACopy ); + assertEquals( nameACopy, nameB ); + assertEquals( nameA, nameB ); + } + + + @Test + public void testHashCodeTransitive() throws Exception + { + assertEquals( nameA.hashCode(), nameACopy.hashCode() ); + assertEquals( nameACopy.hashCode(), nameB.hashCode() ); + assertEquals( nameA.hashCode(), nameB.hashCode() ); + } + + + @Test + public void testNotEqualDiffValue() throws Exception + { + assertFalse( nameA.equals( nameC ) ); + assertFalse( nameC.equals( nameA ) ); + } +} \ No newline at end of file Added: directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/UserClass_SubtreeTest.java URL: http://svn.apache.org/viewvc/directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/UserClass_SubtreeTest.java?rev=964361&view=auto ============================================================================== --- directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/UserClass_SubtreeTest.java (added) +++ directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/aci/UserClass_SubtreeTest.java Thu Jul 15 10:04:06 2010 @@ -0,0 +1,147 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ +package org.apache.directory.shared.ldap.aci; + + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; + +import java.util.HashSet; +import java.util.Set; + +import org.apache.directory.junit.tools.Concurrent; +import org.apache.directory.junit.tools.ConcurrentJunitRunner; +import org.apache.directory.shared.ldap.aci.UserClass.Subtree; +import org.apache.directory.shared.ldap.name.DN; +import org.apache.directory.shared.ldap.subtree.BaseSubtreeSpecification; +import org.apache.directory.shared.ldap.subtree.SubtreeSpecification; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + + +/** + * Unit tests class UserClass.Subtree. + * + * @author Apache Directory Project + */ +@RunWith(ConcurrentJunitRunner.class) +@Concurrent() +public class UserClass_SubtreeTest +{ + Subtree subtreeA; + Subtree subtreeACopy; + Subtree subtreeB; + Subtree subtreeC; + + + /** + * Initialize name instances + */ + @Before + public void initNames() throws Exception + { + SubtreeSpecification subtreeSpecA = new BaseSubtreeSpecification(); + SubtreeSpecification subtreeSpecB = new BaseSubtreeSpecification(); + SubtreeSpecification subtreeSpecC = new BaseSubtreeSpecification(); + SubtreeSpecification subtreeSpecD = new BaseSubtreeSpecification( new DN( "cn=dummy" ) ); + + Set colA = new HashSet(); + colA.add( subtreeSpecA ); + colA.add( subtreeSpecB ); + colA.add( subtreeSpecC ); + Set colB = new HashSet(); + colB.add( subtreeSpecA ); + colB.add( subtreeSpecB ); + colB.add( subtreeSpecC ); + Set colC = new HashSet(); + colC.add( subtreeSpecB ); + colC.add( subtreeSpecC ); + colC.add( subtreeSpecD ); + + subtreeA = new Subtree( colA ); + subtreeACopy = new Subtree( colA ); + subtreeB = new Subtree( colB ); + subtreeC = new Subtree( colC ); + } + + + @Test + public void testEqualsNull() throws Exception + { + assertFalse( subtreeA.equals( null ) ); + } + + + @Test + public void testEqualsReflexive() throws Exception + { + assertEquals( subtreeA, subtreeA ); + } + + + @Test + public void testHashCodeReflexive() throws Exception + { + assertEquals( subtreeA.hashCode(), subtreeA.hashCode() ); + } + + + @Test + public void testEqualsSymmetric() throws Exception + { + assertEquals( subtreeA, subtreeACopy ); + assertEquals( subtreeACopy, subtreeA ); + } + + + @Test + public void testHashCodeSymmetric() throws Exception + { + assertEquals( subtreeA.hashCode(), subtreeACopy.hashCode() ); + assertEquals( subtreeACopy.hashCode(), subtreeA.hashCode() ); + } + + + @Test + public void testEqualsTransitive() throws Exception + { + assertEquals( subtreeA, subtreeACopy ); + assertEquals( subtreeACopy, subtreeB ); + assertEquals( subtreeA, subtreeB ); + } + + + @Test + public void testHashCodeTransitive() throws Exception + { + assertEquals( subtreeA.hashCode(), subtreeACopy.hashCode() ); + assertEquals( subtreeACopy.hashCode(), subtreeB.hashCode() ); + assertEquals( subtreeA.hashCode(), subtreeB.hashCode() ); + } + + + @Test + public void testNotEqualDiffValue() throws Exception + { + assertFalse( subtreeA.equals( subtreeC ) ); + assertFalse( subtreeC.equals( subtreeA ) ); + } +} Added: directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/subtree/SubtreeSpecificationParserTest.java URL: http://svn.apache.org/viewvc/directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/subtree/SubtreeSpecificationParserTest.java?rev=964361&view=auto ============================================================================== --- directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/subtree/SubtreeSpecificationParserTest.java (added) +++ directory/shared/trunk/ldap-schema-manager-tests/src/test/java/org/apache/directory/shared/ldap/subtree/SubtreeSpecificationParserTest.java Thu Jul 15 10:04:06 2010 @@ -0,0 +1,486 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ + +package org.apache.directory.shared.ldap.subtree; + + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.text.ParseException; +import java.util.ArrayList; +import java.util.List; + +import org.apache.directory.junit.tools.Concurrent; +import org.apache.directory.junit.tools.ConcurrentJunitRunner; +import org.apache.directory.shared.ldap.name.DN; +import org.apache.directory.shared.ldap.schema.ObjectClass; +import org.apache.directory.shared.ldap.schema.SchemaManager; +import org.apache.directory.shared.ldap.schema.loader.ldif.JarLdifSchemaLoader; +import org.apache.directory.shared.ldap.schema.manager.impl.DefaultSchemaManager; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** + * Unit tests class for Subtree Specification parser (wrapper). + * + * @author Apache Directory Project + */ +@RunWith(ConcurrentJunitRunner.class) +@Concurrent() +public class SubtreeSpecificationParserTest +{ + /** the ACIItem checker wrapper */ + private static SubtreeSpecificationChecker checker; + + /** the ss parser wrapper */ + private static SubtreeSpecificationParser parser; + + /** A valid empty specification with single white space between brackets */ + private static final String EMPTY_SPEC = "{ }"; + + /** A valid specification only with base set */ + private static final String SPEC_WITH_BASE = "{ base \"ou=system\" }"; + + /** An invalid specification with missing white space and base set */ + private static final String INVALID_SPEC_WITH_BASE_AND_MISSING_WS = "{ base\"ou=system\"}"; + + /** A valid specification with some specific exclusions set */ + private static final String SPEC_WITH_SPECIFICEXCLUSIONS = "{ specificExclusions { chopAfter:\"ef=gh\", chopBefore:\"ab=cd\" } }"; + + /** A valid specification with empty specific exclusions set */ + private static final String SPEC_WITH_EMPTY_SPECIFICEXCLUSIONS = "{ specificExclusions { } }"; + + /** A valid specification with minimum and maximum set */ + private static final String SPEC_WITH_MINIMUM_AND_MAXIMUM = "{ minimum 1, maximum 2 }"; + + /** A valid specification with base and minimum and maximum set */ + private static final String SPEC_WITH_BASE_AND_MINIMUM_AND_MAXIMUM = "{ base \"ou=ORGANIZATION UNIT\", minimum 1, maximum 2 }"; + + /** + * A valid specification with base and specific exclusions and minimum and + * maximum set + */ + private static final String SPEC_WITH_BASE_AND_SPECIFICEXCLUSIONS_AND_MINIMUM_AND_MAXIMUM = "{ base \"ou=people\", specificExclusions { chopBefore:\"x=y\"" + + ", chopAfter:\"k=l\", chopBefore:\"y=z\", chopAfter:\"l=m\" }, minimum 7, maximum 77 }"; + + /** A valid specification with refinement set */ + private static final String SPEC_WITH_REFINEMENT = "{ base \"ou=system\", specificationFilter and:{ and:{ item:2.5.6.0" + + ", or:{ item:2.5.6.1, item:person } }, not: item:2.5.6.2 } }"; + + /** A valid specification with base and an empty refinement set */ + private static final String SPEC_WITH_BASE_AND_EMPTY_REFINEMENT = "{ base \"ou=system\", specificationFilter and:{ } }"; + + /** A valid specification with ALL IN ONE */ + private static final String SPEC_WITH_ALL_IN_ONE = "{ base \"ou=departments\"" + + ", specificExclusions { chopBefore:\"x=y\", chopAfter:\"k=l\", chopBefore:\"y=z\", chopAfter:\"l=m\" }" + + ", minimum 7, maximum 77" + + ", specificationFilter and:{ and:{ item:2.5.6.0, or:{ item:2.5.6.1, item:2.5.6.2 } }, not: item:2.5.6.3 } }"; + + /** An valid specification with unordinary component order */ + private static final String SPEC_ORDER_OF_COMPONENTS_DOES_NOT_MATTER = "{ base \"ou=system\", minimum 3, specificExclusions { chopBefore:\"x=y\" } }"; + + /** An invalid specification with completely unrelated content */ + private static final String INVALID_SILLY_THING = "How much wood would a wood chuck chuck if a wood chuck would chuck wood?"; + + /** holds multithreaded success value */ + boolean isSuccessMultithreaded = true; + + /** The schema manager */ + private static SchemaManager schemaManager; + + /** Some global OC */ + private static ObjectClass TOP_OC; // 2.5.6.0 + private static ObjectClass ALIAS_OC; // 2.5.6.1 + private static ObjectClass COUNTRY_OC; // 2.5.6.2 + private static ObjectClass LOCALITY_OC; // 2.5.6.3 + private static ObjectClass PERSON_OC; // 2.5.6.6 + + /** + * Initialization + */ + @BeforeClass + public static void init() throws Exception + { + JarLdifSchemaLoader loader = new JarLdifSchemaLoader(); + schemaManager = new DefaultSchemaManager( loader ); + + schemaManager.loadAllEnabled(); + + checker = new SubtreeSpecificationChecker( schemaManager ); + parser = new SubtreeSpecificationParser( schemaManager ); + + TOP_OC = schemaManager.lookupObjectClassRegistry( "top" ); + ALIAS_OC = schemaManager.lookupObjectClassRegistry( "alias" ); + COUNTRY_OC = schemaManager.lookupObjectClassRegistry( "country" ); + LOCALITY_OC = schemaManager.lookupObjectClassRegistry( "locality" ); + PERSON_OC = schemaManager.lookupObjectClassRegistry( "person" ); + } + + + /** + * Tests the parser with a valid empty specification. + */ + @Test + public void testEmptySpec() throws Exception + { + SubtreeSpecification ss = parser.parse( EMPTY_SPEC ); + assertNotNull( ss ); + + // try a second time + ss = parser.parse( EMPTY_SPEC ); + assertNotNull( ss ); + + // try a third time + ss = parser.parse( EMPTY_SPEC ); + assertNotNull( ss ); + } + + + /** + * Tests the parser with a valid specification with base set. + */ + @Test + public void testSpecWithBase() throws Exception + { + SubtreeSpecification ss = parser.parse( SPEC_WITH_BASE ); + assertNotNull( ss ); + + assertEquals( "ou=system", ss.getBase().toString() ); + } + + + /** + * Tests the parser with an invalid specification with missing white spaces + * and base set. + */ + @Test + public void testInvalidSpecWithBaseAndMissingWS() throws Exception + { + try + { + parser.parse( INVALID_SPEC_WITH_BASE_AND_MISSING_WS ); + fail( "testInvalidSpecWithBaseAndMissingWS() should never come here..." ); + } + catch ( ParseException e ) + { + assertNotNull( e ); + } + } + + + /** + * Tests the parser with a valid specification with some specific exclusions + * set. + */ + @Test + public void testSpecWithSpecificExclusions() throws Exception + { + SubtreeSpecification ss = parser.parse( SPEC_WITH_SPECIFICEXCLUSIONS ); + assertFalse( ss.getChopBeforeExclusions().isEmpty() ); + assertFalse( ss.getChopAfterExclusions().isEmpty() ); + assertTrue( ss.getChopBeforeExclusions().contains( new DN( "ab=cd" ) ) ); + assertTrue( ss.getChopAfterExclusions().contains( new DN( "ef=gh" ) ) ); + + // try a second time + ss = parser.parse( SPEC_WITH_SPECIFICEXCLUSIONS ); + assertFalse( ss.getChopBeforeExclusions().isEmpty() ); + assertFalse( ss.getChopAfterExclusions().isEmpty() ); + assertTrue( ss.getChopBeforeExclusions().contains( new DN( "ab=cd" ) ) ); + assertTrue( ss.getChopAfterExclusions().contains( new DN( "ef=gh" ) ) ); + + // try a third time + ss = parser.parse( SPEC_WITH_SPECIFICEXCLUSIONS ); + assertFalse( ss.getChopBeforeExclusions().isEmpty() ); + assertFalse( ss.getChopAfterExclusions().isEmpty() ); + assertTrue( ss.getChopBeforeExclusions().contains( new DN( "ab=cd" ) ) ); + assertTrue( ss.getChopAfterExclusions().contains( new DN( "ef=gh" ) ) ); + } + + + /** + * Tests the parser with a valid specification with an empty specific + * exclusions set. + */ + @Test + public void testSpecWithEmptySpecificExclusions() throws Exception + { + SubtreeSpecification ss = parser.parse( SPEC_WITH_EMPTY_SPECIFICEXCLUSIONS ); + assertNotNull( ss ); + + assertTrue( ss.getChopBeforeExclusions().isEmpty() ); + } + + + /** + * Tests the parser with a valid specification with minimum and maximum set. + */ + @Test + public void testSpecWithMinimumAndMaximum() throws Exception + { + SubtreeSpecification ss = parser.parse( SPEC_WITH_MINIMUM_AND_MAXIMUM ); + assertEquals( 1, ss.getMinBaseDistance() ); + assertEquals( 2, ss.getMaxBaseDistance() ); + + // try a second time + ss = parser.parse( SPEC_WITH_MINIMUM_AND_MAXIMUM ); + assertEquals( 1, ss.getMinBaseDistance() ); + assertEquals( 2, ss.getMaxBaseDistance() ); + + // try a third time + ss = parser.parse( SPEC_WITH_MINIMUM_AND_MAXIMUM ); + assertEquals( 1, ss.getMinBaseDistance() ); + assertEquals( 2, ss.getMaxBaseDistance() ); + } + + + /** + * Tests the parser with a valid specification with base and minimum and + * maximum set. + */ + @Test + public void testWithBaseAndMinimumAndMaximum() throws Exception + { + SubtreeSpecification ss = parser.parse( SPEC_WITH_BASE_AND_MINIMUM_AND_MAXIMUM ); + + assertEquals( new DN( "ou=ORGANIZATION UNIT" ).getName(), ss.getBase().getName() ); + assertEquals( 1, ss.getMinBaseDistance() ); + assertEquals( 2, ss.getMaxBaseDistance() ); + } + + + /** + * Tests the parser with a valid specification with base and specific + * exclusions and minimum and maximum set. + */ + @Test + public void testSpecWithBaseAndSpecificExclusionsAndMinimumAndMaximum() throws Exception + { + SubtreeSpecification ss = parser.parse( SPEC_WITH_BASE_AND_SPECIFICEXCLUSIONS_AND_MINIMUM_AND_MAXIMUM ); + assertNotNull( ss ); + + assertEquals( "ou=people", ss.getBase().toString() ); + assertTrue( ss.getChopBeforeExclusions().contains( new DN( "x=y" ).normalize( schemaManager.getNormalizerMapping() ) ) ); + assertTrue( ss.getChopBeforeExclusions().contains( new DN( "y=z" ).normalize( schemaManager.getNormalizerMapping() ) ) ); + assertTrue( ss.getChopAfterExclusions().contains( new DN( "k=l" ).normalize( schemaManager.getNormalizerMapping() ) ) ); + assertTrue( ss.getChopAfterExclusions().contains( new DN( "l=m" ).normalize( schemaManager.getNormalizerMapping() ) ) ); + assertEquals( 7, ss.getMinBaseDistance() ); + assertEquals( 77, ss.getMaxBaseDistance() ); + } + + + /** + * Tests the parser with a valid specification with refinement set. + */ + @Test + public void testSpecWithRefinement() throws Exception + { + SubtreeSpecification ss = parser.parse( SPEC_WITH_REFINEMENT ); + + // The items + Refinement topItem = new ItemRefinement( TOP_OC ); + Refinement aliasItem = new ItemRefinement( ALIAS_OC ); + Refinement personItem = new ItemRefinement( PERSON_OC ); + Refinement countryItem = new ItemRefinement( COUNTRY_OC ); + + // The inner OR refinement or:{item:2.5.6.1, item:person} + List orList = new ArrayList(); + orList.add( aliasItem ); + orList.add( personItem ); + + Refinement orRefinement = new OrRefinement( orList ); + + // The inner AND refinement and:{ item:2.5.6.0, or:... } + List innerAndList = new ArrayList(); + innerAndList.add( topItem ); + innerAndList.add( orRefinement ); + + Refinement innerAndRefinement = new AndRefinement( innerAndList ); + + // The NOT refinement not:item:2.5.6.2 + Refinement notRefinement = new NotRefinement( countryItem ); + + // The outer AND refinement and:{and:..., not:...} + List outerAndList = new ArrayList(); + outerAndList.add( innerAndRefinement ); + outerAndList.add( notRefinement ); + + Refinement outerAndRefinement = new AndRefinement( outerAndList ); + + StringBuilder buffer = new StringBuilder(); + ss.getRefinement().printRefinementToBuffer( buffer ); + + //assertEquals( outerAndRefinement.toString(), buffer ); + assertEquals( "and: { and: { item: 2.5.6.0, or: { item: 2.5.6.1, item: person } }, not: item: 2.5.6.2 }", buffer.toString() ); + } + + + /** + * Tests the parser with a valid specification with base and empty + * refinement set. + */ + @Test + public void testSpecWithBaseAndEmptyRefinement() throws Exception + { + SubtreeSpecification ss = parser.parse( SPEC_WITH_BASE_AND_EMPTY_REFINEMENT ); + + assertEquals( "ou=system", ss.getBase().toString() ); + } + + + /** + * Tests the parser with a valid specification with all components set. + */ + @Test + public void testSpecWithAllInOne() throws Exception + { + SubtreeSpecification ss = parser.parse( SPEC_WITH_ALL_IN_ONE ); + assertNotNull( ss ); + } + + + /** + * Tests the parser with a valid specification with unordinary component + * order. + */ + @Test + public void testSpecOrderOfComponentsDoesNotMatter() throws Exception + { + SubtreeSpecification ss = parser.parse( SPEC_ORDER_OF_COMPONENTS_DOES_NOT_MATTER ); + assertNotNull( ss ); + } + + + /** + * Tests the parser with an invalid specification with silly things in. + */ + @Test + public void testInvalidSillyThing() throws Exception + { + try + { + parser.parse( INVALID_SILLY_THING ); + fail( "testInvalidSillyThing() should never come here..." ); + } + catch ( ParseException e ) + { + assertNotNull( e ); + } + } + + + /** + * Test reusability, especially if the state is resetted. + */ + @Test + public void testReusabiltiy() throws Exception + { + DN firstDN = new DN("k=l"); + String firstExclusion = "{ specificExclusions { chopAfter:\"k=l\" } }"; + SubtreeSpecification firstSpec = parser.parse( firstExclusion ); + assertEquals( 1, firstSpec.getChopAfterExclusions().size() ); + assertEquals( firstDN, firstSpec.getChopAfterExclusions().iterator().next() ); + + DN secondDN = new DN("x=y"); + String secondExclusion = "{ specificExclusions { chopAfter:\"x=y\" } }"; + SubtreeSpecification secondSpec = parser.parse( secondExclusion ); + assertEquals( 1, secondSpec.getChopAfterExclusions().size() ); + assertEquals( secondDN, secondSpec.getChopAfterExclusions().iterator().next() ); + + } + + + /** + * Tests the multithreaded use of a single parser. + */ + @Test + public void testMultiThreaded() throws Exception + { + // start up and track all threads (40 threads) + List threads = new ArrayList(); + for ( int ii = 0; ii < 10; ii++ ) + { + Thread t0 = new Thread( new ParseSpecification( EMPTY_SPEC ) ); + Thread t1 = new Thread( new ParseSpecification( SPEC_WITH_SPECIFICEXCLUSIONS ) ); + Thread t2 = new Thread( new ParseSpecification( SPEC_WITH_MINIMUM_AND_MAXIMUM ) ); + Thread t3 = new Thread( new ParseSpecification( SPEC_WITH_ALL_IN_ONE ) ); + threads.add( t0 ); + threads.add( t1 ); + threads.add( t2 ); + threads.add( t3 ); + t0.start(); + t1.start(); + t2.start(); + t3.start(); + } + + // wait until all threads have died + boolean hasLiveThreads = false; + do + { + hasLiveThreads = false; + + for ( int ii = 0; ii < threads.size(); ii++ ) + { + Thread t = threads.get( ii ); + hasLiveThreads = hasLiveThreads || t.isAlive(); + } + } + while ( hasLiveThreads ); + + // check that no one thread failed to parse and generate a SS object + assertTrue( isSuccessMultithreaded ); + } + + /** + * Used to test multithreaded use of a single parser. + */ + class ParseSpecification implements Runnable + { + private final String specStr; + + SubtreeSpecification result; + + + public ParseSpecification(String specStr) + { + this.specStr = specStr; + } + + + public void run() + { + try + { + result = parser.parse( specStr ); + } + catch ( ParseException e ) + { + e.printStackTrace(); + } + + isSuccessMultithreaded = isSuccessMultithreaded && ( result != null ); + } + } +} Modified: directory/shared/trunk/ldap/pom.xml URL: http://svn.apache.org/viewvc/directory/shared/trunk/ldap/pom.xml?rev=964361&r1=964360&r2=964361&view=diff ============================================================================== --- directory/shared/trunk/ldap/pom.xml (original) +++ directory/shared/trunk/ldap/pom.xml Thu Jul 15 10:04:06 2010 @@ -87,7 +87,7 @@ org.apache.maven.plugins maven-antlr-plugin - schema-extension.g schema-qdstring.g schema-value.g schema.g TriggerSpecification.g distinguishedName.g + schema-extension.g schema-qdstring.g schema-value.g schema.g TriggerSpecification.g distinguishedName.g ACIItem.g ACIItemChecker.g subtree-specification.g SubtreeSpecificationChecker.g Added: directory/shared/trunk/ldap/src/main/antlr/ACIItem.g URL: http://svn.apache.org/viewvc/directory/shared/trunk/ldap/src/main/antlr/ACIItem.g?rev=964361&view=auto ============================================================================== --- directory/shared/trunk/ldap/src/main/antlr/ACIItem.g (added) +++ directory/shared/trunk/ldap/src/main/antlr/ACIItem.g Thu Jul 15 10:04:06 2010 @@ -0,0 +1,1547 @@ +header +{ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ + + +package org.apache.directory.shared.ldap.aci; + + +import java.util.List; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; +import java.util.Enumeration; + +import org.apache.directory.shared.ldap.filter.BranchNode; +import org.apache.directory.shared.ldap.filter.AndNode; +import org.apache.directory.shared.ldap.filter.OrNode; +import org.apache.directory.shared.ldap.filter.NotNode; +import org.apache.directory.shared.ldap.filter.ExprNode; +import org.apache.directory.shared.ldap.filter.LeafNode; +import org.apache.directory.shared.ldap.filter.EqualityNode; +import org.apache.directory.shared.ldap.filter.FilterParser; +import org.apache.directory.shared.ldap.name.NameComponentNormalizer; +import org.apache.directory.shared.ldap.subtree.SubtreeSpecification; +import org.apache.directory.shared.ldap.subtree.SubtreeSpecificationModifier; +import org.apache.directory.shared.ldap.util.ComponentsMonitor; +import org.apache.directory.shared.ldap.util.MandatoryAndOptionalComponentsMonitor; +import org.apache.directory.shared.ldap.util.MandatoryComponentsMonitor; +import org.apache.directory.shared.ldap.util.NamespaceTools; +import org.apache.directory.shared.ldap.util.NoDuplicateKeysMap; +import org.apache.directory.shared.ldap.util.OptionalComponentsMonitor; +import org.apache.directory.shared.ldap.name.DN; +import org.apache.directory.shared.ldap.name.RDN; +import org.apache.directory.shared.ldap.schema.AttributeType; +import org.apache.directory.shared.ldap.schema.SchemaManager; +import org.apache.directory.shared.ldap.constants.SchemaConstants; +import org.apache.directory.shared.ldap.constants.AuthenticationLevel; +import org.apache.directory.shared.ldap.entry.StringValue; +import org.apache.directory.shared.ldap.entry.EntryAttribute; +import org.apache.directory.shared.ldap.entry.DefaultEntryAttribute; +import org.apache.directory.shared.ldap.exception.LdapException; +import org.apache.directory.shared.ldap.aci.protectedItem.AllAttributeValuesItem; +import org.apache.directory.shared.ldap.aci.protectedItem.AttributeTypeItem; +import org.apache.directory.shared.ldap.aci.protectedItem.AttributeValueItem; +import org.apache.directory.shared.ldap.aci.protectedItem.SelfValueItem; +import org.apache.directory.shared.ldap.aci.protectedItem.ClassesItem; +import org.apache.directory.shared.ldap.aci.protectedItem.EntryItem; +import org.apache.directory.shared.ldap.aci.protectedItem.RangeOfValuesItem; +import org.apache.directory.shared.ldap.aci.protectedItem.MaxImmSubItem; +import org.apache.directory.shared.ldap.aci.protectedItem.MaxValueCountElem; +import org.apache.directory.shared.ldap.aci.protectedItem.MaxValueCountItem; +import org.apache.directory.shared.ldap.aci.protectedItem.RestrictedByElem; +import org.apache.directory.shared.ldap.aci.protectedItem.RestrictedByItem; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +} + + +// ---------------------------------------------------------------------------- +// parser class definition +// ---------------------------------------------------------------------------- + +/** + * The antlr generated ACIItem parser. + * + * @author Apache Directory Project + */ +class AntlrACIItemParser extends Parser; + + +// ---------------------------------------------------------------------------- +// parser options +// ---------------------------------------------------------------------------- + +options +{ + k = 1; // ;-) + defaultErrorHandler = false; +} + + +// ---------------------------------------------------------------------------- +// imaginary tokens +// ---------------------------------------------------------------------------- + +tokens +{ + ATTRIBUTE_VALUE_CANDIDATE; + RANGE_OF_VALUES_CANDIDATE; +} + + +// ---------------------------------------------------------------------------- +// parser initialization +// ---------------------------------------------------------------------------- + +{ + private static final Logger log = LoggerFactory.getLogger( AntlrACIItemParser.class ); + + NameComponentNormalizer normalizer; + + // nonshared global data needed to avoid extensive pass/return stuff + // these are only used by three first order components + private String identificationTag; + private AuthenticationLevel authenticationLevel; + private Integer aciPrecedence = null; + + private boolean isItemFirstACIItem; + + // shared global data needed to avoid extensive pass/return stuff + private Set protectedItems; + private Map protectedItemsMap; + private Set userClasses; + private Map userClassesMap; + private Set itemPermissions; + private Integer precedence = null; + private Set grantsAndDenials; + private Set userPermissions; + + /** The SchemaManager */ + private SchemaManager schemaManager; + + private Set chopBeforeExclusions; + private Set chopAfterExclusions; + private SubtreeSpecificationModifier ssModifier = null; + + private ComponentsMonitor mainACIItemComponentsMonitor; + private ComponentsMonitor itemPermissionComponentsMonitor; + private ComponentsMonitor userPermissionComponentsMonitor; + private ComponentsMonitor subtreeSpecificationComponentsMonitor; + + + /** + * Creates a (normalizing) subordinate DnParser for parsing Names. + * This method MUST be called for each instance while we cannot do + * constructor overloading for this class. + * + * @return the DnParser to be used for parsing Names + */ + public void init( SchemaManager schemaManager ) + { + this.schemaManager = schemaManager; + } + + /** + * Sets the NameComponentNormalizer for this parser's dnParser. + */ + public void setNormalizer(NameComponentNormalizer normalizer) + { + this.normalizer = normalizer; + } + + private int token2Integer( Token token ) throws RecognitionException + { + int i = 0; + + try + { + i = Integer.parseInt( token.getText()); + } + catch ( NumberFormatException e ) + { + throw new RecognitionException( "Value of INTEGER token " + + token.getText() + + " cannot be converted to an Integer" ); + } + + return i; + } +} + + +// ---------------------------------------------------------------------------- +// parser productions +// ---------------------------------------------------------------------------- + +wrapperEntryPoint returns [ ACIItem aciItem ] +{ + log.debug( "entered wrapperEntryPoint()" ); + aciItem = null; +} + : + ( SP )* aciItem = theACIItem ( SP )* EOF + ; + +theACIItem returns [ ACIItem aciItem ] +{ + log.debug( "entered theACIItem()" ); + aciItem = null; + mainACIItemComponentsMonitor = new MandatoryComponentsMonitor( + new String [] { "identificationTag", "precedence", "authenticationLevel", "itemOrUserFirst" } ); +} + : + OPEN_CURLY + ( SP )* mainACIItemComponent ( SP )* + ( SEP ( SP )* mainACIItemComponent ( SP )* )* + CLOSE_CURLY + { + if ( !mainACIItemComponentsMonitor.finalStateValid() ) + { + throw new RecognitionException( "Missing mandatory ACIItem components: " + + mainACIItemComponentsMonitor.getRemainingComponents() ); + } + + if ( isItemFirstACIItem ) + { + aciItem = new ItemFirstACIItem( + identificationTag, + aciPrecedence, + authenticationLevel, + protectedItems, + itemPermissions ); + } + else + { + aciItem = new UserFirstACIItem( + identificationTag, + aciPrecedence, + authenticationLevel, + userClasses, + userPermissions ); + } + } + ; + +mainACIItemComponent +{ + log.debug( "entered mainACIItemComponent()" ); +} + : + aci_identificationTag + { + mainACIItemComponentsMonitor.useComponent( "identificationTag" ); + } + | aci_precedence + { + mainACIItemComponentsMonitor.useComponent( "precedence" ); + } + | aci_authenticationLevel + { + mainACIItemComponentsMonitor.useComponent( "authenticationLevel" ); + } + | aci_itemOrUserFirst + { + mainACIItemComponentsMonitor.useComponent( "itemOrUserFirst" ); + } + ; + exception + catch [IllegalArgumentException e] + { + throw new RecognitionException( e.getMessage() ); + } + +aci_identificationTag +{ + log.debug( "entered aci_identificationTag()" ); +} + : + ID_identificationTag ( SP )+ token:SAFEUTF8STRING + { + identificationTag = token.getText(); + } + ; + +aci_precedence +{ + log.debug( "entered aci_precedence()" ); +} + : + precedence + { + aciPrecedence = Integer.valueOf( precedence ); + precedence = null; + } + ; + +precedence +{ + log.debug( "entered precedence()" ); +} + : + ID_precedence ( SP )+ token:INTEGER + { + precedence = Integer.valueOf( token2Integer( token ) ); + + if ( ( precedence < 0 ) || ( precedence > 255 ) ) + { + throw new RecognitionException( "Expecting INTEGER token having an Integer value between 0 and 255, found " + precedence ); + } + } + ; + +aci_authenticationLevel +{ + log.debug( "entered aci_authenticationLevel()" ); +} + : + ID_authenticationLevel ( SP )+ authenticationLevel + ; + +authenticationLevel +{ + log.debug( "entered authenticationLevel()" ); +} + : + ID_none + { + authenticationLevel = AuthenticationLevel.NONE; + } + | + ID_simple + { + authenticationLevel = AuthenticationLevel.SIMPLE; + } + | + ID_strong + { + authenticationLevel = AuthenticationLevel.STRONG; + } + ; + +aci_itemOrUserFirst +{ + log.debug( "entered aci_itemOrUserFirst()" ); +} + : + ID_itemOrUserFirst ( SP )+ itemOrUserFirst + ; + +itemOrUserFirst +{ + log.debug( "entered itemOrUserFirst()" ); +} + : + itemFirst | userFirst + ; + +itemFirst +{ + log.debug( "entered itemFirst()" ); +} + : + ID_itemFirst ( SP )* COLON ( SP )* + OPEN_CURLY ( SP )* + protectedItems ( SP )* SEP ( SP )* itemPermissions + ( SP )* CLOSE_CURLY + { + isItemFirstACIItem = true; + } + ; + +userFirst +{ + log.debug( "entered userFirst()" ); +} + : + ID_userFirst ( SP )* COLON ( SP )* + OPEN_CURLY ( SP )* + userClasses ( SP )* SEP ( SP )* userPermissions + ( SP )* CLOSE_CURLY + { + isItemFirstACIItem = false; + } + ; + +protectedItems +{ + log.debug( "entered protectedItems()" ); + protectedItemsMap = new NoDuplicateKeysMap(); +} + : + ID_protectedItems ( SP )* + OPEN_CURLY ( SP )* + ( + protectedItem ( SP )* + ( SEP ( SP )* protectedItem ( SP )* )* + )? + CLOSE_CURLY + { + protectedItems = new HashSet( protectedItemsMap.values() ); + } + ; + exception + catch [IllegalArgumentException e] + { + throw new RecognitionException( "Protected Items cannot be duplicated. " + e.getMessage() ); + } + +protectedItem +{ + log.debug( "entered protectedItem()" ); +} + : + entry + | allUserAttributeTypes + | attributeType + | allAttributeValues + | allUserAttributeTypesAndValues + | attributeValue + | selfValue + | rangeOfValues + | maxValueCount + | maxImmSub + | restrictedBy + | classes + ; + +entry +{ + log.debug( "entered entry()" ); +} + : + ID_entry + { + protectedItemsMap.put( "entry", ProtectedItem.ENTRY ); + } + ; + +allUserAttributeTypes +{ + log.debug( "entered allUserAttributeTypes()" ); +} + : + ID_allUserAttributeTypes + { + protectedItemsMap.put( "allUserAttributeTypes", ProtectedItem.ALL_USER_ATTRIBUTE_TYPES ); + } + ; + +attributeType +{ + log.debug( "entered attributeType()" ); + Set attributeTypeSet = null; +} + : + ID_attributeType ( SP )+ attributeTypeSet=attributeTypeSet + { + protectedItemsMap.put( "attributeType", new AttributeTypeItem(attributeTypeSet ) ); + } + ; + +allAttributeValues +{ + log.debug( "entered allAttributeValues()" ); + Set attributeTypeSet = null; +} + : + ID_allAttributeValues ( SP )+ attributeTypeSet=attributeTypeSet + { + protectedItemsMap.put( "allAttributeValues", new AllAttributeValuesItem( attributeTypeSet ) ); + } + ; + +allUserAttributeTypesAndValues +{ + log.debug( "entered allUserAttributeTypesAndValues()" ); +} + : + ID_allUserAttributeTypesAndValues + { + protectedItemsMap.put( "allUserAttributeTypesAndValues", ProtectedItem.ALL_USER_ATTRIBUTE_TYPES_AND_VALUES ); + } + ; + +attributeValue +{ + log.debug( "entered attributeValue()" ); + String attributeTypeAndValue = null; + String attributeType = null; + String attributeValue = null; + Set attributeSet = new HashSet(); +} + : + token:ATTRIBUTE_VALUE_CANDIDATE // ate the identifier for subordinate dn parser workaround + { + // A Dn can be considered as a set of attributeTypeAndValues + // So, parse the set as a Dn and extract each attributeTypeAndValue + DN attributeTypeAndValueSetAsDn = new DN( token.getText() ); + + if ( schemaManager != null ) + { + attributeTypeAndValueSetAsDn.normalize( schemaManager.getNormalizerMapping() ); + } + + for ( RDN rdn :attributeTypeAndValueSetAsDn.getRdns() ) + { + attributeTypeAndValue = rdn.getNormName(); + attributeType = NamespaceTools.getRdnAttribute( attributeTypeAndValue ); + attributeValue = NamespaceTools.getRdnValue( attributeTypeAndValue ); + + attributeSet.add( new DefaultEntryAttribute( attributeType, attributeValue ) ); + log.debug( "An attributeTypeAndValue from the set: " + attributeType + "=" + attributeValue); + } + + protectedItemsMap.put( "attributeValue", new AttributeValueItem( attributeSet ) ); + } + ; + exception + catch [Exception e] + { + throw new RecognitionException( "dnParser failed for " + token.getText() + " , " + e.getMessage() ); + } + +selfValue +{ + log.debug( "entered selfValue()" ); + Set attributeTypeSet = null; +} + : + ID_selfValue ( SP )+ attributeTypeSet=attributeTypeSet + { + protectedItemsMap.put( "sefValue", new SelfValueItem( attributeTypeSet ) ); + } + ; + +rangeOfValues +{ + log.debug( "entered rangeOfValues()" ); +} + : + token:RANGE_OF_VALUES_CANDIDATE + { + protectedItemsMap.put( "rangeOfValues", + new RangeOfValuesItem( + FilterParser.parse( token.getText() ) ) ); + log.debug( "filterParser parsed " + token.getText() ); + } + ; + exception + catch [Exception e] + { + throw new RecognitionException( "filterParser failed. " + e.getMessage() ); + } + +maxValueCount +{ + log.debug( "entered maxValueCount()" ); + MaxValueCountElem maxValueCount = null; + Set maxValueCountSet = new HashSet(); +} + : + ID_maxValueCount ( SP )+ + OPEN_CURLY ( SP )* + maxValueCount=aMaxValueCount ( SP )* + { + maxValueCountSet.add( maxValueCount ); + } + ( SEP ( SP )* maxValueCount=aMaxValueCount ( SP )* + { + maxValueCountSet.add( maxValueCount ); + } + )* + CLOSE_CURLY + { + protectedItemsMap.put( "maxValueCount", new MaxValueCountItem( maxValueCountSet ) ); + } + ; + +aMaxValueCount returns [ MaxValueCountElem maxValueCount ] +{ + log.debug( "entered aMaxValueCount()" ); + maxValueCount = null; + String oid = null; + Token token = null; + AttributeType attributeType = null; +} + : + OPEN_CURLY ( SP )* + ( + ID_type ( SP )+ oid=oid ( SP )* SEP ( SP )* + ID_maxCount ( SP )+ token1:INTEGER + { token = token1; } + | // relaxing + ID_maxCount ( SP )+ token2:INTEGER ( SP )* SEP ( SP )* + ID_type ( SP )+ oid=oid + { token = token2; } + ) + ( SP )* CLOSE_CURLY + { + try + { + attributeType = schemaManager.lookupAttributeTypeRegistry( oid ); + maxValueCount = new MaxValueCountElem( attributeType, token2Integer( token ) ); + } + catch ( LdapException le ) + { + // The oid does not exist + // TODO : deal with such an exception + } + } + ; + +maxImmSub +{ + log.debug( "entered maxImmSub()" ); +} + : + ID_maxImmSub ( SP )+ token:INTEGER + { + + protectedItemsMap.put( "maxImmSub", + new MaxImmSubItem( + token2Integer( token ) ) ); + } + ; + +restrictedBy +{ + log.debug( "entered restrictedBy()" ); + RestrictedByElem restrictedValue = null; + Set restrictedBy = new HashSet(); +} + : + ID_restrictedBy ( SP )+ + OPEN_CURLY ( SP )* + restrictedValue=restrictedValue ( SP )* + { + restrictedBy.add( restrictedValue ); + } + ( SEP ( SP )* restrictedValue=restrictedValue ( SP )* + { + restrictedBy.add( restrictedValue ); + } + )* + CLOSE_CURLY + { + protectedItemsMap.put( "restrictedBy", new RestrictedByItem( restrictedBy ) ); + } + ; + +restrictedValue returns [ RestrictedByElem restrictedValue ] +{ + log.debug( "entered restrictedValue()" ); + String typeOid = null; + String valuesInOid = null; + restrictedValue = null; + AttributeType attributeType = null; + AttributeType valueInAttributeType = null; +} + : + OPEN_CURLY ( SP )* + ( + ID_type ( SP )+ typeOid=oid ( SP )* SEP ( SP )* + ID_valuesIn ( SP )+ valuesInOid=oid + | // relaxing + ID_valuesIn ( SP )+ valuesInOid=oid ( SP )* SEP ( SP )* + ID_type ( SP )+ typeOid=oid + ) + ( SP )* CLOSE_CURLY + { + try + { + attributeType = schemaManager.lookupAttributeTypeRegistry( typeOid ); + valueInAttributeType = schemaManager.lookupAttributeTypeRegistry( valuesInOid ); + restrictedValue = new RestrictedByElem( attributeType, valueInAttributeType ); + } + catch ( LdapException le ) + { + // The oid does not exist + // TODO : deal with such an exception + } + } + ; + +attributeTypeSet returns [ Set attributeTypeSet ] +{ + log.debug( "entered attributeTypeSet()" ); + String oid = null; + attributeTypeSet = new HashSet(); + AttributeType attributeType = null; +} + : + OPEN_CURLY ( SP )* + oid=oid ( SP )* + { + try + { + attributeType = schemaManager.lookupAttributeTypeRegistry( oid ); + attributeTypeSet.add( attributeType ); + } + catch ( LdapException le ) + { + // The oid does not exist + // TODO : deal with such an exception + } + } + ( SEP ( SP )* oid=oid ( SP )* + { + try + { + attributeType = schemaManager.lookupAttributeTypeRegistry( oid ); + attributeTypeSet.add( attributeType ); + } + catch ( LdapException le ) + { + // The oid does not exist + // TODO : deal with such an exception + } + } + )* + CLOSE_CURLY + ; + +classes +{ + log.debug( "entered classes()" ); + ExprNode classes = null; +} + : + ID_classes ( SP )+ classes=refinement + { + protectedItemsMap.put( "classes", new ClassesItem( classes ) ); + } + ; + +itemPermissions +{ + log.debug( "entered itemPermissions()" ); + itemPermissions = new HashSet(); + ItemPermission itemPermission = null; +} + : + ID_itemPermissions ( SP )+ + OPEN_CURLY ( SP )* + ( itemPermission=itemPermission ( SP )* + { + itemPermissions.add( itemPermission ); + } + ( SEP ( SP )* itemPermission=itemPermission ( SP )* + { + itemPermissions.add( itemPermission ); + } + )* + )? + CLOSE_CURLY + ; + +itemPermission returns [ ItemPermission itemPermission ] +{ + log.debug( "entered itemPermission()" ); + itemPermission = null; + itemPermissionComponentsMonitor = new MandatoryAndOptionalComponentsMonitor( + new String [] { "userClasses", "grantsAndDenials" }, new String [] { "precedence" } ); +} + : + OPEN_CURLY ( SP )* + anyItemPermission ( SP )* + ( SEP ( SP )* anyItemPermission ( SP )* )* + CLOSE_CURLY + { + if ( !itemPermissionComponentsMonitor.finalStateValid() ) + { + throw new RecognitionException( "Missing mandatory itemPermission components: " + + itemPermissionComponentsMonitor.getRemainingComponents() ); + } + + itemPermission = new ItemPermission( precedence, grantsAndDenials, userClasses ); + precedence = null; + } + ; + +anyItemPermission + : + precedence + { + itemPermissionComponentsMonitor.useComponent( "precedence" ); + } + | userClasses + { + itemPermissionComponentsMonitor.useComponent( "userClasses" ); + } + | grantsAndDenials + { + itemPermissionComponentsMonitor.useComponent( "grantsAndDenials" ); + } + ; + exception + catch [IllegalArgumentException e] + { + throw new RecognitionException( e.getMessage() ); + } + +grantsAndDenials +{ + log.debug( "entered grantsAndDenials()" ); + grantsAndDenials = new HashSet(); + GrantAndDenial grantAndDenial = null; +} + : + ID_grantsAndDenials ( SP )+ + OPEN_CURLY ( SP )* + ( grantAndDenial = grantAndDenial ( SP )* + { + if ( !grantsAndDenials.add( grantAndDenial )) + { + throw new RecognitionException( "Duplicated GrantAndDenial bit: " + grantAndDenial ); + } + } + ( SEP ( SP )* grantAndDenial = grantAndDenial ( SP )* + { + if ( !grantsAndDenials.add( grantAndDenial )) + { + throw new RecognitionException( "Duplicated GrantAndDenial bit: " + grantAndDenial ); + } + } + )* + )? + CLOSE_CURLY + ; + +grantAndDenial returns [ GrantAndDenial l_grantAndDenial ] +{ + log.debug( "entered grantAndDenialsBit()" ); + l_grantAndDenial = null; +} + : + ID_grantAdd { l_grantAndDenial = GrantAndDenial.GRANT_ADD; } + | ID_denyAdd { l_grantAndDenial = GrantAndDenial.DENY_ADD; } + | ID_grantDiscloseOnError { l_grantAndDenial = GrantAndDenial.GRANT_DISCLOSE_ON_ERROR; } + | ID_denyDiscloseOnError { l_grantAndDenial = GrantAndDenial.DENY_DISCLOSE_ON_ERROR; } + | ID_grantRead { l_grantAndDenial = GrantAndDenial.GRANT_READ; } + | ID_denyRead { l_grantAndDenial = GrantAndDenial.DENY_READ; } + | ID_grantRemove { l_grantAndDenial = GrantAndDenial.GRANT_REMOVE; } + | ID_denyRemove { l_grantAndDenial = GrantAndDenial.DENY_REMOVE; } + //-- permissions that may be used only in conjunction + //-- with the entry component + | ID_grantBrowse { l_grantAndDenial = GrantAndDenial.GRANT_BROWSE; } + | ID_denyBrowse { l_grantAndDenial = GrantAndDenial.DENY_BROWSE; } + | ID_grantExport { l_grantAndDenial = GrantAndDenial.GRANT_EXPORT; } + | ID_denyExport { l_grantAndDenial = GrantAndDenial.DENY_EXPORT; } + | ID_grantImport { l_grantAndDenial = GrantAndDenial.GRANT_IMPORT; } + | ID_denyImport { l_grantAndDenial = GrantAndDenial.DENY_IMPORT; } + | ID_grantModify { l_grantAndDenial = GrantAndDenial.GRANT_MODIFY; } + | ID_denyModify { l_grantAndDenial = GrantAndDenial.DENY_MODIFY; } + | ID_grantRename { l_grantAndDenial = GrantAndDenial.GRANT_RENAME; } + | ID_denyRename { l_grantAndDenial = GrantAndDenial.DENY_RENAME; } + | ID_grantReturnDN { l_grantAndDenial = GrantAndDenial.GRANT_RETURN_DN; } + | ID_denyReturnDN { l_grantAndDenial = GrantAndDenial.DENY_RETURN_DN; } + //-- permissions that may be used in conjunction + //-- with any component, except entry, of ProtectedItems + | ID_grantCompare { l_grantAndDenial = GrantAndDenial.GRANT_COMPARE; } + | ID_denyCompare { l_grantAndDenial = GrantAndDenial.DENY_COMPARE; } + | ID_grantFilterMatch { l_grantAndDenial = GrantAndDenial.GRANT_FILTER_MATCH; } + | ID_denyFilterMatch { l_grantAndDenial = GrantAndDenial.DENY_FILTER_MATCH; } + | ID_grantInvoke { l_grantAndDenial = GrantAndDenial.GRANT_INVOKE; } + | ID_denyInvoke { l_grantAndDenial = GrantAndDenial.DENY_INVOKE; } + ; + +userClasses +{ + log.debug( "entered userClasses()" ); + userClassesMap = new NoDuplicateKeysMap(); +} + : + ID_userClasses ( SP )+ + OPEN_CURLY ( SP )* + ( + userClass ( SP )* + ( SEP ( SP )* userClass ( SP )* )* + )? + CLOSE_CURLY + { + userClasses = new HashSet( userClassesMap.values() ); + } + ; + exception + catch [IllegalArgumentException e] + { + throw new RecognitionException( "User Classes cannot be duplicated. " + e.getMessage() ); + } + +userClass +{ + log.debug( "entered userClasses()" ); +} + : + allUsers + | thisEntry + | parentOfEntry + | name + | userGroup + | subtree + ; + +allUsers +{ + log.debug( "entered allUsers()" ); +} + : + ID_allUsers + { + userClassesMap.put( "allUsers", UserClass.ALL_USERS ); + } + ; + +thisEntry +{ + log.debug( "entered thisEntry()" ); +} + : + ID_thisEntry + { + userClassesMap.put( "thisEntry", UserClass.THIS_ENTRY ); + } + ; + +parentOfEntry +{ + log.debug( "entered parentOfEntry()" ); +} + : + ID_parentOfEntry + { + userClassesMap.put( "parentOfEntry", UserClass.PARENT_OF_ENTRY ); + } + ; + +name +{ + log.debug( "entered name()" ); + Set names = new HashSet(); + DN distinguishedName = null; +} + : + ID_name ( SP )+ + OPEN_CURLY ( SP )* + distinguishedName=distinguishedName ( SP )* + { + names.add( distinguishedName ); + } + ( SEP ( SP )* distinguishedName=distinguishedName ( SP )* + { + names.add( distinguishedName ); + } )* + CLOSE_CURLY + { + userClassesMap.put( "name", new UserClass.Name( names ) ); + } + ; + +userGroup +{ + log.debug( "entered userGroup()" ); + Set userGroup = new HashSet(); + DN distinguishedName = null; +} + : + ID_userGroup ( SP )+ + OPEN_CURLY ( SP )* + distinguishedName=distinguishedName ( SP )* + { + userGroup.add( distinguishedName ); + } + ( SEP ( SP )* distinguishedName=distinguishedName ( SP )* + { + userGroup.add( distinguishedName ); + } )* + CLOSE_CURLY + { + userClassesMap.put( "userGroup", new UserClass.UserGroup( userGroup ) ); + } + ; + +subtree +{ + log.debug( "entered subtree()" ); + Set subtrees = new HashSet(); + SubtreeSpecification subtreeSpecification = null; +} + : + ID_subtree ( SP )+ + OPEN_CURLY ( SP )* + subtreeSpecification=subtreeSpecification ( SP )* + { + subtrees.add( subtreeSpecification ); + } + ( SEP ( SP )* subtreeSpecification=subtreeSpecification ( SP )* + { + subtrees.add( subtreeSpecification ); + } )* + CLOSE_CURLY + { + userClassesMap.put( "subtree", new UserClass.Subtree( subtrees ) ); + } + ; + +userPermissions +{ + log.debug( "entered userPermissions()" ); + userPermissions = new HashSet(); + UserPermission userPermission = null; +} + : + ID_userPermissions ( SP )+ + OPEN_CURLY ( SP )* + ( userPermission=userPermission ( SP )* + { + userPermissions.add( userPermission ); + } + ( SEP ( SP )* userPermission=userPermission ( SP )* + { + userPermissions.add( userPermission ); + } + )* + )? + CLOSE_CURLY + ; + +userPermission returns [ UserPermission userPermission ] +{ + log.debug( "entered userPermission()" ); + userPermission = null; + userPermissionComponentsMonitor = new MandatoryAndOptionalComponentsMonitor( + new String [] { "protectedItems", "grantsAndDenials" }, new String [] { "precedence" } ); +} + : + OPEN_CURLY ( SP )* + anyUserPermission ( SP )* + ( SEP ( SP )* anyUserPermission ( SP )* )* + CLOSE_CURLY + { + if ( !userPermissionComponentsMonitor.finalStateValid() ) + { + throw new RecognitionException( "Missing mandatory userPermission components: " + + userPermissionComponentsMonitor.getRemainingComponents() ); + } + + userPermission = new UserPermission( precedence, grantsAndDenials, protectedItems ); + precedence = null; + } + ; + +anyUserPermission + : + precedence + { + userPermissionComponentsMonitor.useComponent( "precedence" ); + } + | protectedItems + { + userPermissionComponentsMonitor.useComponent( "protectedItems" ); + } + | grantsAndDenials + { + userPermissionComponentsMonitor.useComponent( "grantsAndDenials" ); + } + ; + exception + catch [IllegalArgumentException e] + { + throw new RecognitionException( e.getMessage() ); + } + +subtreeSpecification returns [SubtreeSpecification ss] +{ + log.debug( "entered subtreeSpecification()" ); + // clear out ss, ssModifier, chopBeforeExclusions and chopAfterExclusions + // in case something is left from the last parse + ss = null; + ssModifier = new SubtreeSpecificationModifier(); + chopBeforeExclusions = new HashSet(); + chopAfterExclusions = new HashSet(); + subtreeSpecificationComponentsMonitor = new OptionalComponentsMonitor( + new String [] { "base", "specificExclusions", "minimum", "maximum" } ); +} + : + OPEN_CURLY ( SP )* + ( subtreeSpecificationComponent ( SP )* + ( SEP ( SP )* subtreeSpecificationComponent ( SP )* )* )? + CLOSE_CURLY + { + ss = ssModifier.getSubtreeSpecification(); + } + ; + +subtreeSpecificationComponent +{ + log.debug( "entered subtreeSpecification()" ); +} + : + ss_base + { + subtreeSpecificationComponentsMonitor.useComponent( "base" ); + } + | ss_specificExclusions + { + subtreeSpecificationComponentsMonitor.useComponent( "specificExclusions" ); + } + | ss_minimum + { + subtreeSpecificationComponentsMonitor.useComponent( "minimum" ); + } + | ss_maximum + { + subtreeSpecificationComponentsMonitor.useComponent( "maximum" ); + } + ; + exception + catch [IllegalArgumentException e] + { + throw new RecognitionException( e.getMessage() ); + } + +ss_base +{ + log.debug( "entered ss_base()" ); + DN base = null; +} + : + ID_base ( SP )+ base=distinguishedName + { + ssModifier.setBase( base ); + } + ; + +ss_specificExclusions +{ + log.debug( "entered ss_specificExclusions()" ); +} + : + ID_specificExclusions ( SP )+ specificExclusions + { + ssModifier.setChopBeforeExclusions( chopBeforeExclusions ); + ssModifier.setChopAfterExclusions( chopAfterExclusions ); + } + ; + +specificExclusions +{ + log.debug( "entered specificExclusions()" ); +} + : + OPEN_CURLY ( SP )* + ( specificExclusion ( SP )* + ( SEP ( SP )* specificExclusion ( SP )* )* + )? + CLOSE_CURLY + ; + +specificExclusion +{ + log.debug( "entered specificExclusion()" ); +} + : + chopBefore | chopAfter + ; + +chopBefore +{ + log.debug( "entered chopBefore()" ); + DN chopBeforeExclusion = null; +} + : + ID_chopBefore ( SP )* COLON ( SP )* chopBeforeExclusion=distinguishedName + { + chopBeforeExclusions.add( chopBeforeExclusion ); + } + ; + +chopAfter +{ + log.debug( "entered chopAfter()" ); + DN chopAfterExclusion = null; +} + : + ID_chopAfter ( SP )* COLON ( SP )* chopAfterExclusion=distinguishedName + { + chopAfterExclusions.add( chopAfterExclusion ); + } + ; + +ss_minimum +{ + log.debug( "entered ss_minimum()" ); + int minimum = 0; +} + : + ID_minimum ( SP )+ minimum=baseDistance + { + ssModifier.setMinBaseDistance( minimum ); + } + ; + +ss_maximum +{ + log.debug( "entered ss_maximum()" ); + int maximum = 0; +} + : + ID_maximum ( SP )+ maximum=baseDistance + { + ssModifier.setMaxBaseDistance( maximum ); + } + ; + +distinguishedName returns [ DN name ] +{ + log.debug( "entered distinguishedName()" ); + name = null; +} + : + token:SAFEUTF8STRING + { + name = new DN( token.getText() ); + if ( schemaManager != null ) + { + name.normalize( schemaManager.getNormalizerMapping() ); + } + log.debug( "recognized a DistinguishedName: " + token.getText() ); + } + ; + exception + catch [Exception e] + { + throw new RecognitionException( "dnParser failed for " + token.getText() + " " + e.getMessage() ); + } + +baseDistance returns [ int distance ] +{ + log.debug( "entered baseDistance()" ); + distance = 0; +} + : + token:INTEGER + { + distance = token2Integer( token ); + } + ; + +oid returns [ String result ] +{ + log.debug( "entered oid()" ); + result = null; + Token token = null; +} + : + { token = LT( 1 ); } // an interesting trick goes here ;-) + ( DESCR | NUMERICOID ) + { + result = token.getText(); + log.debug( "recognized an oid: " + result ); + } + ; + +refinement returns [ ExprNode node ] +{ + log.debug( "entered refinement()" ); + node = null; +} + : + node=item | node=and | node=or | node=not + ; + +item returns [ LeafNode node ] +{ + log.debug( "entered item()" ); + node = null; + String oid = null; +} + : + ID_item ( SP )* COLON ( SP )* oid=oid + { + node = new EqualityNode( SchemaConstants.OBJECT_CLASS_AT , new StringValue( oid ) ); + } + ; + +and returns [ BranchNode node ] +{ + log.debug( "entered and()" ); + node = null; + List children = null; +} + : + ID_and ( SP )* COLON ( SP )* children=refinements + { + node = new AndNode( children ); + } + ; + +or returns [ BranchNode node ] +{ + log.debug( "entered or()" ); + node = null; + List children = null; +} + : + ID_or ( SP )* COLON ( SP )* children=refinements + { + node = new OrNode( children ); + } + ; + +not returns [ BranchNode node ] +{ + log.debug( "entered not()" ); + node = null; + List children = null; +} + : + ID_not ( SP )* COLON ( SP )* children=refinements + { + node = new NotNode( children ); + } + ; + +refinements returns [ List children ] +{ + log.debug( "entered refinements()" ); + children = null; + ExprNode child = null; + List tempChildren = new ArrayList(); +} + : + OPEN_CURLY ( SP )* + ( + child=refinement ( SP )* + { + tempChildren.add( child ); + } + ( SEP ( SP )* child=refinement ( SP )* + { + tempChildren.add( child ); + } )* + )? CLOSE_CURLY + { + children = tempChildren; + } + ; + + +// ---------------------------------------------------------------------------- +// lexer class definition +// ---------------------------------------------------------------------------- + +/** + * The parser's primary lexer. + * + * @author Apache Directory Project + */ +class AntlrACIItemLexer extends Lexer; + + +// ---------------------------------------------------------------------------- +// lexer options +// ---------------------------------------------------------------------------- + +options +{ + k = 2; + charVocabulary = '\3'..'\377'; +} + + +//---------------------------------------------------------------------------- +// tokens +//---------------------------------------------------------------------------- + +tokens +{ + ID_identificationTag = "identificationTag"; + ID_precedence = "precedence"; + ID_FALSE = "FALSE"; + ID_TRUE = "TRUE"; + ID_none = "none"; + ID_simple = "simple"; + ID_strong = "strong"; + ID_level = "level"; + ID_basicLevels = "basicLevels"; + ID_localQualifier = "localQualifier"; + ID_signed = "signed"; + ID_authenticationLevel = "authenticationLevel"; + ID_itemOrUserFirst = "itemOrUserFirst"; + ID_itemFirst = "itemFirst"; + ID_userFirst = "userFirst"; + ID_protectedItems = "protectedItems"; + ID_classes = "classes"; + ID_entry = "entry"; + ID_allUserAttributeTypes = "allUserAttributeTypes"; + ID_attributeType = "attributeType"; + ID_allAttributeValues = "allAttributeValues"; + ID_allUserAttributeTypesAndValues = "allUserAttributeTypesAndValues"; + ID_selfValue = "selfValue"; + ID_item = "item"; + ID_and = "and"; + ID_or = "or"; + ID_not = "not"; + ID_rangeOfValues = "rangeOfValues"; + ID_maxValueCount = "maxValueCount"; + ID_type = "type"; + ID_maxCount = "maxCount"; + ID_maxImmSub = "maxImmSub"; + ID_restrictedBy = "restrictedBy"; + ID_valuesIn = "valuesIn"; + ID_userClasses = "userClasses"; + ID_base = "base"; + ID_specificExclusions = "specificExclusions"; + ID_chopBefore = "chopBefore"; + ID_chopAfter = "chopAfter"; + ID_minimum = "minimum"; + ID_maximum = "maximum"; + ID_specificationFilter = "specificationFilter"; + ID_grantsAndDenials = "grantsAndDenials"; + ID_itemPermissions = "itemPermissions"; + ID_userPermissions = "userPermissions"; + ID_allUsers = "allUsers"; + ID_thisEntry = "thisEntry"; + ID_parentOfEntry = "parentOfEntry"; + ID_subtree = "subtree"; + ID_name = "name"; + ID_userGroup = "userGroup"; + + ID_grantAdd = "grantAdd"; // (0), + ID_denyAdd = "denyAdd"; // (1), + ID_grantDiscloseOnError = "grantDiscloseOnError"; // (2), + ID_denyDiscloseOnError = "denyDiscloseOnError"; // (3), + ID_grantRead = "grantRead"; // (4), + ID_denyRead = "denyRead"; // (5), + ID_grantRemove = "grantRemove"; // (6), + ID_denyRemove = "denyRemove"; // (7), + //-- permissions that may be used only in conjunction + //-- with the entry component + ID_grantBrowse = "grantBrowse"; // (8), + ID_denyBrowse = "denyBrowse"; // (9), + ID_grantExport = "grantExport"; // (10), + ID_denyExport = "denyExport"; // (11), + ID_grantImport = "grantImport"; // (12), + ID_denyImport = "denyImport"; // (13), + ID_grantModify = "grantModify"; // (14), + ID_denyModify = "denyModify"; // (15), + ID_grantRename = "grantRename"; // (16), + ID_denyRename = "denyRename"; // (17), + ID_grantReturnDN = "grantReturnDN"; // (18), + ID_denyReturnDN = "denyReturnDN"; // (19), + //-- permissions that may be used in conjunction + //-- with any component, except entry, of ProtectedItems + ID_grantCompare = "grantCompare"; // (20), + ID_denyCompare = "denyCompare"; // (21), + ID_grantFilterMatch = "grantFilterMatch"; // (22), + ID_denyFilterMatch = "denyFilterMatch"; // (23), + ID_grantInvoke = "grantInvoke"; // (24), + ID_denyInvoke = "denyInvoke"; // (25) +} + + +// ---------------------------------------------------------------------------- +// lexer initialization +// ---------------------------------------------------------------------------- + +{ + private static final Logger log = LoggerFactory.getLogger( AntlrACIItemLexer.class ); +} + + +// ---------------------------------------------------------------------------- +// attribute description lexer rules from models +// ---------------------------------------------------------------------------- + +// This is all messed up - could not figure out how to get antlr to represent +// the safe UTF-8 character set from RFC 3642 for production SafeUTF8Character + +protected SAFEUTF8CHAR : + '\u0001'..'\u0021' | + '\u0023'..'\u007F' | + '\u00c0'..'\u00d6' | + '\u00d8'..'\u00f6' | + '\u00f8'..'\u00ff' | + '\u0100'..'\u1fff' | + '\u3040'..'\u318f' | + '\u3300'..'\u337f' | + '\u3400'..'\u3d2d' | + '\u4e00'..'\u9fff' | + '\uf900'..'\ufaff' ; + +OPEN_CURLY : '{' ; + +CLOSE_CURLY : '}' ; + +SEP : ',' ; + +SP : ' ' | '\t' | '\n' { newline(); } | '\r' ; + +COLON : ':' ; + +protected DIGIT : '0' | LDIGIT ; + +protected LDIGIT : '1'..'9' ; + +protected ALPHA : 'A'..'Z' | 'a'..'z' ; + +protected INTEGER : DIGIT | ( LDIGIT ( DIGIT )+ ) ; + +protected HYPHEN : '-' ; + +protected NUMERICOID : INTEGER ( DOT INTEGER )+ ; + +protected DOT : '.' ; + +INTEGER_OR_NUMERICOID + : + ( INTEGER DOT ) => NUMERICOID + { + $setType( NUMERICOID ); + } + | + INTEGER + { + $setType( INTEGER ); + } + ; + +SAFEUTF8STRING : '"'! ( SAFEUTF8CHAR )* '"'! ; + +DESCR // THIS RULE ALSO STANDS FOR AN IDENTIFIER + : + ( "attributeValue" ( SP! )+ '{' ) => + "attributeValue"! ( SP! )+ '{'! ( options { greedy = false; } : . )* '}'! + { $setType( ATTRIBUTE_VALUE_CANDIDATE ); } + | ( "rangeOfValues" ( SP! )+ '(' ) => + "rangeOfValues"! ( SP! )+ FILTER + { $setType( RANGE_OF_VALUES_CANDIDATE ); } + | ALPHA ( ALPHA | DIGIT | HYPHEN )* + ; + +protected FILTER : '(' ( ( '&' (SP)* (FILTER)+ ) | ( '|' (SP)* (FILTER)+ ) | ( '!' (SP)* FILTER ) | FILTER_VALUE ) ')' (SP)* ; + +protected FILTER_VALUE : (options{greedy=true;}: ~( ')' | '(' | '&' | '|' | '!' ) ( ~(')') )* ) ; +