directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From akaras...@apache.org
Subject svn commit: r601657 [2/6] - in /directory/apacheds/branches/bigbang: core-integ/src/main/java/org/apache/directory/server/core/integ/ core-integ/src/test/java/org/apache/directory/server/core/jndi/ core-integ/src/test/java/org/apache/directory/server/c...
Date Thu, 06 Dec 2007 08:39:27 GMT
Added: directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaNormalizerHandlerIT.java
URL: http://svn.apache.org/viewvc/directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaNormalizerHandlerIT.java?rev=601657&view=auto
==============================================================================
--- directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaNormalizerHandlerIT.java (added)
+++ directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaNormalizerHandlerIT.java Thu Dec  6 00:39:23 2007
@@ -0,0 +1,595 @@
+/*
+ *  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.server.core.schema;
+
+
+import org.apache.directory.server.constants.MetaSchemaConstants;
+import org.apache.directory.server.core.DirectoryService;
+import org.apache.directory.server.core.integ.CiRunner;
+import org.apache.directory.server.core.integ.SetupMode;
+import org.apache.directory.server.core.integ.annotations.Mode;
+import static org.apache.directory.server.core.integ.IntegrationUtils.getSchemaContext;
+import org.apache.directory.server.schema.registries.MatchingRuleRegistry;
+import org.apache.directory.server.schema.registries.NormalizerRegistry;
+import org.apache.directory.shared.ldap.constants.SchemaConstants;
+import org.apache.directory.shared.ldap.exception.LdapInvalidNameException;
+import org.apache.directory.shared.ldap.exception.LdapOperationNotSupportedException;
+import org.apache.directory.shared.ldap.message.AttributeImpl;
+import org.apache.directory.shared.ldap.message.AttributesImpl;
+import org.apache.directory.shared.ldap.message.ModificationItemImpl;
+import org.apache.directory.shared.ldap.message.ResultCodeEnum;
+import org.apache.directory.shared.ldap.name.LdapDN;
+import org.apache.directory.shared.ldap.schema.*;
+import static org.junit.Assert.*;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import javax.naming.NamingException;
+import javax.naming.directory.Attribute;
+import javax.naming.directory.Attributes;
+import javax.naming.directory.DirContext;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.util.Comparator;
+
+
+/**
+ * A test case which tests the addition of various schema elements
+ * to the ldap server.
+ *
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ * @version $Rev$
+ */
+@RunWith ( CiRunner.class )
+@Mode ( SetupMode.PRISTINE )
+public class MetaNormalizerHandlerIT
+{
+    private static final String OID = "1.3.6.1.4.1.18060.0.4.0.1.100000";
+    private static final String NEW_OID = "1.3.6.1.4.1.18060.0.4.0.1.100001";
+
+
+    public static DirectoryService service;
+
+
+    /**
+     * Gets relative DN to ou=schema.
+     *
+     * @param schemaName the name of the schema
+     * @return  the name of the container with normalizer entries in it
+     * @throws NamingException on error
+     */
+    private LdapDN getNormalizerContainer( String schemaName ) throws NamingException
+    {
+        return new LdapDN( "ou=normalizers,cn=" + schemaName );
+    }
+    
+
+    private static NormalizerRegistry getNormalizerRegistry()
+    {
+        return service.getRegistries().getNormalizerRegistry();
+    }
+
+
+    private static MatchingRuleRegistry getMatchingRuleRegistry()
+    {
+        return service.getRegistries().getMatchingRuleRegistry();
+    }
+
+
+    // ----------------------------------------------------------------------
+    // Test all core methods with normal operational pathways
+    // ----------------------------------------------------------------------
+
+
+    @Test
+    public void testAddNormalizer() throws NamingException
+    {
+        Attributes attrs = new AttributesImpl();
+        Attribute oc = new AttributeImpl( SchemaConstants.OBJECT_CLASS_AT, "top" );
+        oc.add( MetaSchemaConstants.META_TOP_OC );
+        oc.add( MetaSchemaConstants.META_NORMALIZER_OC );
+        attrs.put( oc );
+        attrs.put( MetaSchemaConstants.M_FQCN_AT, NoOpNormalizer.class.getName() );
+        attrs.put( MetaSchemaConstants.M_OID_AT, OID );
+        attrs.put( MetaSchemaConstants.M_DESCRIPTION_AT, "A test normalizer" );
+        
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        getSchemaContext( service ).createSubcontext( dn, attrs );
+        
+        assertTrue( getNormalizerRegistry().hasNormalizer( OID ) );
+        assertEquals( getNormalizerRegistry().getSchemaName( OID ), "apachemeta" );
+        Class clazz = getNormalizerRegistry().lookup( OID ).getClass();
+        assertEquals( clazz, NoOpNormalizer.class );
+    }
+    
+    
+    @Test
+    public void testAddNormalizerWithByteCode() throws Exception
+    {
+        InputStream in = getClass().getResourceAsStream( "DummyNormalizer.bytecode" );
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        while ( in.available() > 0 )
+        {
+            out.write( in.read() );
+        }
+        
+        Attributes attrs = new AttributesImpl();
+        Attribute oc = new AttributeImpl( SchemaConstants.OBJECT_CLASS_AT, "top" );
+        oc.add( MetaSchemaConstants.META_TOP_OC );
+        oc.add( MetaSchemaConstants.META_NORMALIZER_OC );
+        attrs.put( oc );
+        attrs.put( MetaSchemaConstants.M_FQCN_AT, "DummyNormalizer" );
+        attrs.put( MetaSchemaConstants.M_BYTECODE_AT, out.toByteArray() );
+        attrs.put( MetaSchemaConstants.M_OID_AT, OID );
+        attrs.put( MetaSchemaConstants.M_DESCRIPTION_AT, "A test normalizer" );
+        
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        getSchemaContext( service ).createSubcontext( dn, attrs );
+        
+        assertTrue( getNormalizerRegistry().hasNormalizer( OID ) );
+        assertEquals( getNormalizerRegistry().getSchemaName( OID ), "apachemeta" );
+        Class clazz = getNormalizerRegistry().lookup( OID ).getClass();
+        assertEquals( clazz.getName(), "DummyNormalizer" );
+    }
+    
+    
+    @Test
+    public void testDeleteNormalizer() throws NamingException
+    {
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        testAddNormalizer();
+        
+        getSchemaContext( service ).destroySubcontext( dn );
+
+        assertFalse( "normalizer should be removed from the registry after being deleted", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+
+        //noinspection EmptyCatchBlock
+        try
+        {
+            getNormalizerRegistry().lookup( OID );
+            fail( "normalizer lookup should fail after deleting the normalizer" );
+        }
+        catch( NamingException e )
+        {
+        }
+    }
+
+
+    @Test
+    public void testRenameNormalizer() throws NamingException
+    {
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        testAddNormalizer();
+        
+        LdapDN newdn = getNormalizerContainer( "apachemeta" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + NEW_OID );
+        getSchemaContext( service ).rename( dn, newdn );
+
+        assertFalse( "old normalizer OID should be removed from the registry after being renamed", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+
+        //noinspection EmptyCatchBlock
+        try
+        {
+            getNormalizerRegistry().lookup( OID );
+            fail( "normalizer lookup should fail after deleting the normalizer" );
+        }
+        catch( NamingException e )
+        {
+        }
+
+        assertTrue( getNormalizerRegistry().hasNormalizer( NEW_OID ) );
+        Class clazz = getNormalizerRegistry().lookup( NEW_OID ).getClass();
+        assertEquals( clazz, NoOpNormalizer.class );
+    }
+
+
+    @Test
+    public void testMoveNormalizer() throws NamingException
+    {
+        testAddNormalizer();
+        
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN newdn = getNormalizerContainer( "apache" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        getSchemaContext( service ).rename( dn, newdn );
+
+        assertTrue( "normalizer OID should still be present", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+        
+        assertEquals( "normalizer schema should be set to apache not apachemeta", 
+            getNormalizerRegistry().getSchemaName( OID ), "apache" );
+
+        Class clazz = getNormalizerRegistry().lookup( OID ).getClass();
+        assertEquals( clazz, NoOpNormalizer.class );
+    }
+
+
+    @Test
+    public void testMoveNormalizerAndChangeRdn() throws NamingException
+    {
+        testAddNormalizer();
+        
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN newdn = getNormalizerContainer( "apache" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + NEW_OID );
+        
+        getSchemaContext( service ).rename( dn, newdn );
+
+        assertFalse( "old normalizer OID should NOT be present", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+        
+        assertTrue( "new normalizer OID should be present", 
+            getNormalizerRegistry().hasNormalizer( NEW_OID ) );
+        
+        assertEquals( "normalizer with new oid should have schema set to apache NOT apachemeta", 
+            getNormalizerRegistry().getSchemaName( NEW_OID ), "apache" );
+
+        Class clazz = getNormalizerRegistry().lookup( NEW_OID ).getClass();
+        assertEquals( clazz, NoOpNormalizer.class );
+    }
+
+    
+    @Test
+    public void testModifyNormalizerWithModificationItems() throws NamingException
+    {
+        testAddNormalizer();
+        
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        ModificationItemImpl[] mods = new ModificationItemImpl[1];
+        Attribute attr = new AttributeImpl( MetaSchemaConstants.M_FQCN_AT, DeepTrimNormalizer.class.getName() );
+        mods[0] = new ModificationItemImpl( DirContext.REPLACE_ATTRIBUTE, attr );
+        getSchemaContext( service ).modifyAttributes( dn, mods );
+
+        assertTrue( "normalizer OID should still be present", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+        
+        assertEquals( "normalizer schema should be set to apachemeta", 
+            getNormalizerRegistry().getSchemaName( OID ), "apachemeta" );
+
+        Class clazz = getNormalizerRegistry().lookup( OID ).getClass();
+        assertEquals( clazz, DeepTrimNormalizer.class );
+    }
+
+    
+    @Test
+    public void testModifyNormalizerWithAttributes() throws NamingException
+    {
+        testAddNormalizer();
+        
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        Attributes mods = new AttributesImpl();
+        mods.put( MetaSchemaConstants.M_FQCN_AT, DeepTrimNormalizer.class.getName() );
+        getSchemaContext( service ).modifyAttributes( dn, DirContext.REPLACE_ATTRIBUTE, mods );
+
+        assertTrue( "normalizer OID should still be present", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+        
+        assertEquals( "normalizer schema should be set to apachemeta", 
+            getNormalizerRegistry().getSchemaName( OID ), "apachemeta" );
+
+        Class clazz = getNormalizerRegistry().lookup( OID ).getClass();
+        assertEquals( clazz, DeepTrimNormalizer.class );
+    }
+    
+
+    // ----------------------------------------------------------------------
+    // Test move, rename, and delete when a MR exists and uses the Normalizer
+    // ----------------------------------------------------------------------
+
+    
+    @Test
+    public void testDeleteNormalizerWhenInUse() throws NamingException
+    {
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        testAddNormalizer();
+        getMatchingRuleRegistry().register( new DummyMR() );
+        
+        try
+        {
+            getSchemaContext( service ).destroySubcontext( dn );
+            fail( "should not be able to delete a normalizer in use" );
+        }
+        catch( LdapOperationNotSupportedException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.UNWILLING_TO_PERFORM );
+        }
+
+        assertTrue( "normalizer should still be in the registry after delete failure", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+        getMatchingRuleRegistry().unregister( OID );
+    }
+    
+    
+    @Test
+    public void testMoveNormalizerWhenInUse() throws NamingException
+    {
+        testAddNormalizer();
+        getMatchingRuleRegistry().register( new DummyMR() );
+        
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN newdn = getNormalizerContainer( "apache" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        try
+        {
+            getSchemaContext( service ).rename( dn, newdn );
+            fail( "should not be able to move a normalizer in use" );
+        }
+        catch( LdapOperationNotSupportedException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.UNWILLING_TO_PERFORM );
+        }
+
+        assertTrue( "normalizer should still be in the registry after move failure", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+        getMatchingRuleRegistry().unregister( OID );
+    }
+
+
+    @Test
+    public void testMoveNormalizerAndChangeRdnWhenInUse() throws NamingException
+    {
+        testAddNormalizer();
+        getMatchingRuleRegistry().register( new DummyMR() );
+        
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN newdn = getNormalizerContainer( "apache" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + NEW_OID );
+        
+        try
+        {
+            getSchemaContext( service ).rename( dn, newdn );
+            fail( "should not be able to move a normalizer in use" );
+        }
+        catch( LdapOperationNotSupportedException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.UNWILLING_TO_PERFORM );
+        }
+
+        assertTrue( "normalizer should still be in the registry after move failure", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+        getMatchingRuleRegistry().unregister( OID );
+    }
+
+    
+    @Test
+    public void testRenameNormalizerWhenInUse() throws NamingException
+    {
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        testAddNormalizer();
+        getMatchingRuleRegistry().register( new DummyMR() );
+        
+        LdapDN newdn = getNormalizerContainer( "apachemeta" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + NEW_OID );
+        
+        try
+        {
+            getSchemaContext( service ).rename( dn, newdn );
+            fail( "should not be able to rename a normalizer in use" );
+        }
+        catch( LdapOperationNotSupportedException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.UNWILLING_TO_PERFORM );
+        }
+
+        assertTrue( "normalizer should still be in the registry after rename failure", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+        getMatchingRuleRegistry().unregister( OID );
+    }
+
+
+    // ----------------------------------------------------------------------
+    // Let's try some freaky stuff
+    // ----------------------------------------------------------------------
+
+
+    @Test
+    public void testMoveNormalizerToTop() throws NamingException
+    {
+        testAddNormalizer();
+        
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN top = new LdapDN();
+        top.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        try
+        {
+            getSchemaContext( service ).rename( dn, top );
+            fail( "should not be able to move a normalizer up to ou=schema" );
+        }
+        catch( LdapInvalidNameException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.NAMING_VIOLATION );
+        }
+
+        assertTrue( "normalizer should still be in the registry after move failure", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+    }
+
+
+    @Test
+    public void testMoveNormalizerToComparatorContainer() throws NamingException
+    {
+        testAddNormalizer();
+        
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN newdn = new LdapDN( "ou=comparators,cn=apachemeta" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        try
+        {
+            getSchemaContext( service ).rename( dn, newdn );
+            fail( "should not be able to move a normalizer into comparators container" );
+        }
+        catch( LdapInvalidNameException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.NAMING_VIOLATION );
+        }
+
+        assertTrue( "normalizer should still be in the registry after move failure", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+    }
+    
+    
+    @Test
+    public void testAddNormalizerToDisabledSchema() throws NamingException
+    {
+        Attributes attrs = new AttributesImpl();
+        Attribute oc = new AttributeImpl( SchemaConstants.OBJECT_CLASS_AT, "top" );
+        oc.add( MetaSchemaConstants.META_TOP_OC );
+        oc.add( MetaSchemaConstants.META_NORMALIZER_OC );
+        attrs.put( oc );
+        attrs.put( MetaSchemaConstants.M_FQCN_AT, NoOpNormalizer.class.getName() );
+        attrs.put( MetaSchemaConstants.M_OID_AT, OID );
+        attrs.put( MetaSchemaConstants.M_DESCRIPTION_AT, "A test normalizer" );
+        
+        // nis is by default inactive
+        LdapDN dn = getNormalizerContainer( "nis" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        getSchemaContext( service ).createSubcontext( dn, attrs );
+        
+        assertFalse( "adding new normalizer to disabled schema should not register it into the registries", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+    }
+
+
+    @Test
+    public void testMoveNormalizerToDisabledSchema() throws NamingException
+    {
+        testAddNormalizer();
+        
+        LdapDN dn = getNormalizerContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        // nis is inactive by default
+        LdapDN newdn = getNormalizerContainer( "nis" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        getSchemaContext( service ).rename( dn, newdn );
+
+        assertFalse( "normalizer OID should no longer be present", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+    }
+
+
+    @Test
+    public void testMoveNormalizerToEnabledSchema() throws NamingException
+    {
+        testAddNormalizerToDisabledSchema();
+        
+        // nis is inactive by default
+        LdapDN dn = getNormalizerContainer( "nis" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        assertFalse( "normalizer OID should NOT be present when added to disabled nis schema", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+
+        LdapDN newdn = getNormalizerContainer( "apachemeta" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        getSchemaContext( service ).rename( dn, newdn );
+
+        assertTrue( "normalizer OID should be present when moved to enabled schema", 
+            getNormalizerRegistry().hasNormalizer( OID ) );
+        
+        assertEquals( "normalizer should be in apachemeta schema after move", 
+            getNormalizerRegistry().getSchemaName( OID ), "apachemeta" );
+    }
+
+
+    class DummyMR implements MatchingRule
+    {
+        private static final long serialVersionUID = 1L;
+
+        public Comparator getComparator() throws NamingException
+        {
+            return null;
+        }
+
+        public Normalizer getNormalizer() throws NamingException
+        {
+            return null;
+        }
+
+        public Syntax getSyntax() throws NamingException
+        {
+            return null;
+        }
+
+        public String getDescription()
+        {
+            return null;
+        }
+
+        public String getName()
+        {
+            return "dummy";
+        }
+
+        public String[] getNames()
+        {
+            return new String[] { "dummy" };
+        }
+
+        public String getOid()
+        {
+            return OID;
+        }
+
+        public boolean isObsolete()
+        {
+            return false;
+        }
+
+        public String getSchema()
+        {
+            return null;
+        }
+
+        public void setSchema( String schemaName )
+        {
+        }
+    }
+}

Propchange: directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaNormalizerHandlerIT.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaObjectClassHandlerIT.java
URL: http://svn.apache.org/viewvc/directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaObjectClassHandlerIT.java?rev=601657&view=auto
==============================================================================
--- directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaObjectClassHandlerIT.java (added)
+++ directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaObjectClassHandlerIT.java Thu Dec  6 00:39:23 2007
@@ -0,0 +1,535 @@
+/*
+ *  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.server.core.schema;
+
+
+import org.apache.directory.server.constants.MetaSchemaConstants;
+import org.apache.directory.server.core.DirectoryService;
+import org.apache.directory.server.core.integ.CiRunner;
+import org.apache.directory.server.core.integ.SetupMode;
+import org.apache.directory.server.core.integ.annotations.Mode;
+import static org.apache.directory.server.core.integ.IntegrationUtils.getSchemaContext;
+import org.apache.directory.server.schema.registries.ObjectClassRegistry;
+import org.apache.directory.shared.ldap.constants.SchemaConstants;
+import org.apache.directory.shared.ldap.exception.LdapInvalidNameException;
+import org.apache.directory.shared.ldap.exception.LdapOperationNotSupportedException;
+import org.apache.directory.shared.ldap.message.AttributeImpl;
+import org.apache.directory.shared.ldap.message.AttributesImpl;
+import org.apache.directory.shared.ldap.message.ModificationItemImpl;
+import org.apache.directory.shared.ldap.message.ResultCodeEnum;
+import org.apache.directory.shared.ldap.name.LdapDN;
+import org.apache.directory.shared.ldap.schema.ObjectClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.junit.runner.RunWith;
+
+import javax.naming.NamingException;
+import javax.naming.directory.Attribute;
+import javax.naming.directory.Attributes;
+import javax.naming.directory.DirContext;
+
+
+/**
+ * A test case which tests the addition of various schema elements
+ * to the ldap server.
+ *
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ * @version $Rev$
+ */
+@RunWith ( CiRunner.class )
+@Mode ( SetupMode.PRISTINE )
+public class MetaObjectClassHandlerIT
+{
+    private static final String NAME = "testObjectClass";
+    private static final String NEW_NAME = "alternateName";
+    private static final String DEPENDEE_NAME = "dependeeName";
+
+    private static final String DESCRIPTION0 = "A test objectClass";
+    private static final String DESCRIPTION1 = "An alternate description";
+    
+    private static final String OID = "1.3.6.1.4.1.18060.0.4.0.3.100000";
+    private static final String NEW_OID = "1.3.6.1.4.1.18060.0.4.0.3.100001";
+    private static final String DEPENDEE_OID = "1.3.6.1.4.1.18060.0.4.0.3.100002";
+
+
+    public static DirectoryService service;
+
+    
+    /**
+     * Gets relative DN to ou=schema.
+     *
+     * @param schemaName the name of the schema
+     * @return the dn of the container which contains objectClasses
+     * @throws NamingException on error
+     */
+    private LdapDN getObjectClassContainer( String schemaName ) throws NamingException
+    {
+        return new LdapDN( "ou=objectClasses,cn=" + schemaName );
+    }
+
+
+    private static ObjectClassRegistry getObjectClassRegistry()
+    {
+        return service.getRegistries().getObjectClassRegistry();
+    }
+
+    
+    // ----------------------------------------------------------------------
+    // Test all core methods with normal operational pathways
+    // ----------------------------------------------------------------------
+
+
+    @Test
+    public void testAddObjectClass() throws NamingException
+    {
+        Attributes attrs = new AttributesImpl();
+        Attribute oc = new AttributeImpl( SchemaConstants.OBJECT_CLASS_AT, "top" );
+        oc.add( MetaSchemaConstants.META_TOP_OC );
+        oc.add( MetaSchemaConstants.META_OBJECT_CLASS_OC );
+        attrs.put( oc );
+        attrs.put( MetaSchemaConstants.M_OID_AT, OID );
+        attrs.put( MetaSchemaConstants.M_NAME_AT, NAME);
+        attrs.put( MetaSchemaConstants.M_DESCRIPTION_AT, DESCRIPTION0 );
+        attrs.put( MetaSchemaConstants.M_TYPE_OBJECT_CLASS_AT, "AUXILIARY" );
+        attrs.put( MetaSchemaConstants.M_MUST_AT, "cn" );
+        attrs.put( MetaSchemaConstants.M_MAY_AT, "ou" );
+        
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        getSchemaContext( service ).createSubcontext( dn, attrs );
+        
+        assertTrue( getObjectClassRegistry().hasObjectClass( OID ) );
+        assertEquals( getObjectClassRegistry().getSchemaName( OID ), "apachemeta" );
+    }
+    
+    
+    @Test
+    public void testDeleteAttributeType() throws NamingException
+    {
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        testAddObjectClass();
+        
+        getSchemaContext( service ).destroySubcontext( dn );
+
+        assertFalse( "objectClass should be removed from the registry after being deleted", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+
+        //noinspection EmptyCatchBlock
+        try
+        {
+            getObjectClassRegistry().lookup( OID );
+            fail( "objectClass lookup should fail after deleting it" );
+        }
+        catch( NamingException e )
+        {
+        }
+    }
+
+
+    @Test
+    public void testRenameAttributeType() throws NamingException
+    {
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        testAddObjectClass();
+        
+        LdapDN newdn = getObjectClassContainer( "apachemeta" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + NEW_OID );
+        getSchemaContext( service ).rename( dn, newdn );
+
+        assertFalse( "old objectClass OID should be removed from the registry after being renamed", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+
+        //noinspection EmptyCatchBlock
+        try
+        {
+            getObjectClassRegistry().lookup( OID );
+            fail( "objectClass lookup should fail after renaming the objectClass" );
+        }
+        catch( NamingException e )
+        {
+        }
+
+        assertTrue( getObjectClassRegistry().hasObjectClass( NEW_OID ) );
+    }
+
+
+    @Test
+    public void testMoveAttributeType() throws NamingException
+    {
+        testAddObjectClass();
+        
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN newdn = getObjectClassContainer( "apache" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        getSchemaContext( service ).rename( dn, newdn );
+
+        assertTrue( "objectClass OID should still be present", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+        
+        assertEquals( "objectClass schema should be set to apache not apachemeta", 
+            getObjectClassRegistry().getSchemaName( OID ), "apache" );
+    }
+
+
+    @Test
+    public void testMoveObjectClassAndChangeRdn() throws NamingException
+    {
+        testAddObjectClass();
+        
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN newdn = getObjectClassContainer( "apache" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + NEW_OID );
+        
+        getSchemaContext( service ).rename( dn, newdn );
+
+        assertFalse( "old objectClass OID should NOT be present", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+        
+        assertTrue( "new objectClass OID should be present", 
+            getObjectClassRegistry().hasObjectClass( NEW_OID ) );
+        
+        assertEquals( "objectClass with new oid should have schema set to apache NOT apachemeta", 
+            getObjectClassRegistry().getSchemaName( NEW_OID ), "apache" );
+    }
+
+    
+    @Test
+    public void testModifyAttributeTypeWithModificationItems() throws NamingException
+    {
+        testAddObjectClass();
+        
+        ObjectClass oc = getObjectClassRegistry().lookup( OID );
+        assertEquals( oc.getDescription(), DESCRIPTION0 );
+        assertEquals( oc.getName(), NAME );
+
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        ModificationItemImpl[] mods = new ModificationItemImpl[2];
+        Attribute attr = new AttributeImpl( MetaSchemaConstants.M_DESCRIPTION_AT, DESCRIPTION1 );
+        mods[0] = new ModificationItemImpl( DirContext.REPLACE_ATTRIBUTE, attr );
+        attr = new AttributeImpl( MetaSchemaConstants.M_NAME_AT, NEW_NAME );
+        mods[1] = new ModificationItemImpl( DirContext.REPLACE_ATTRIBUTE, attr );
+        getSchemaContext( service ).modifyAttributes( dn, mods );
+
+        assertTrue( "objectClass OID should still be present", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+        
+        assertEquals( "objectClass schema should be set to apachemeta", 
+            getObjectClassRegistry().getSchemaName( OID ), "apachemeta" );
+        
+        oc = getObjectClassRegistry().lookup( OID );
+        assertEquals( oc.getDescription(), DESCRIPTION1 );
+        assertEquals( oc.getName(), NEW_NAME );
+    }
+
+    
+    @Test
+    public void testModifyAttributeTypeWithAttributes() throws NamingException
+    {
+        testAddObjectClass();
+        
+        ObjectClass oc = getObjectClassRegistry().lookup( OID );
+        assertEquals( oc.getDescription(), DESCRIPTION0 );
+        assertEquals( oc.getName(), NAME );
+
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        Attributes mods = new AttributesImpl();
+        mods.put( MetaSchemaConstants.M_DESCRIPTION_AT, DESCRIPTION1 );
+        mods.put( MetaSchemaConstants.M_NAME_AT, NEW_NAME );
+        getSchemaContext( service ).modifyAttributes( dn, DirContext.REPLACE_ATTRIBUTE, mods );
+
+        assertTrue( "objectClass OID should still be present", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+        
+        assertEquals( "objectClass schema should be set to apachemeta", 
+            getObjectClassRegistry().getSchemaName( OID ), "apachemeta" );
+
+        oc = getObjectClassRegistry().lookup( OID );
+        assertEquals( oc.getDescription(), DESCRIPTION1 );
+        assertEquals( oc.getName(), NEW_NAME );
+    }
+    
+
+    // ----------------------------------------------------------------------
+    // Test move, rename, and delete when a OC exists and uses the OC as sup
+    // ----------------------------------------------------------------------
+
+    
+    private void addDependeeObjectClass() throws NamingException
+    {
+        Attributes attrs = new AttributesImpl();
+        Attribute oc = new AttributeImpl( SchemaConstants.OBJECT_CLASS_AT, "top" );
+        oc.add( MetaSchemaConstants.META_TOP_OC );
+        oc.add( MetaSchemaConstants.META_OBJECT_CLASS_OC );
+        attrs.put( oc );
+        attrs.put( MetaSchemaConstants.M_OID_AT, DEPENDEE_OID );
+        attrs.put( MetaSchemaConstants.M_NAME_AT, DEPENDEE_NAME );
+        attrs.put( MetaSchemaConstants.M_DESCRIPTION_AT, DESCRIPTION0 );
+        attrs.put( MetaSchemaConstants.M_TYPE_OBJECT_CLASS_AT, "AUXILIARY" );
+        attrs.put( MetaSchemaConstants.M_MUST_AT, "cn" );
+        attrs.put( MetaSchemaConstants.M_MAY_AT, "ou" );
+        attrs.put( MetaSchemaConstants.M_SUP_OBJECT_CLASS_AT, OID );
+        
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + DEPENDEE_OID );
+        getSchemaContext( service ).createSubcontext( dn, attrs );
+        
+        assertTrue( getObjectClassRegistry().hasObjectClass( DEPENDEE_OID ) );
+        assertEquals( getObjectClassRegistry().getSchemaName( DEPENDEE_OID ), "apachemeta" );
+    }
+
+    
+    @Test
+    public void testDeleteObjectClassWhenInUse() throws NamingException
+    {
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        testAddObjectClass();
+        addDependeeObjectClass();
+        
+        try
+        {
+            getSchemaContext( service ).destroySubcontext( dn );
+            fail( "should not be able to delete a objectClass in use" );
+        }
+        catch( LdapOperationNotSupportedException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.UNWILLING_TO_PERFORM );
+        }
+
+        assertTrue( "objectClass should still be in the registry after delete failure", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+    }
+    
+    
+    @Test
+    public void testMoveObjectClassWhenInUse() throws NamingException
+    {
+        testAddObjectClass();
+        addDependeeObjectClass();
+        
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN newdn = getObjectClassContainer( "apache" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        try
+        {
+            getSchemaContext( service ).rename( dn, newdn );
+            fail( "should not be able to move a objectClass in use" );
+        }
+        catch( LdapOperationNotSupportedException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.UNWILLING_TO_PERFORM );
+        }
+
+        assertTrue( "objectClass should still be in the registry after move failure", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+    }
+
+
+    @Test
+    public void testMoveObjectClassAndChangeRdnWhenInUse() throws NamingException
+    {
+        testAddObjectClass();
+        addDependeeObjectClass();
+        
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN newdn = getObjectClassContainer( "apache" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + NEW_OID );
+        
+        try
+        {
+            getSchemaContext( service ).rename( dn, newdn );
+            fail( "should not be able to move an objectClass in use" );
+        }
+        catch( LdapOperationNotSupportedException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.UNWILLING_TO_PERFORM );
+        }
+
+        assertTrue( "ObjectClass should still be in the registry after move failure", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+    }
+
+    
+    @Test
+    public void testRenameObjectClassWhenInUse() throws NamingException
+    {
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        testAddObjectClass();
+        addDependeeObjectClass();
+        
+        LdapDN newdn = getObjectClassContainer( "apachemeta" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + NEW_OID );
+        
+        try
+        {
+            getSchemaContext( service ).rename( dn, newdn );
+            fail( "should not be able to rename an objectClass in use" );
+        }
+        catch( LdapOperationNotSupportedException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.UNWILLING_TO_PERFORM );
+        }
+
+        assertTrue( "objectClass should still be in the registry after rename failure", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+    }
+
+
+    // ----------------------------------------------------------------------
+    // Let's try some freaky stuff
+    // ----------------------------------------------------------------------
+
+
+    @Test
+    public void testMoveObjectClassToTop() throws NamingException
+    {
+        testAddObjectClass();
+        
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN top = new LdapDN();
+        top.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        try
+        {
+            getSchemaContext( service ).rename( dn, top );
+            fail( "should not be able to move a objectClass up to ou=schema" );
+        }
+        catch( LdapInvalidNameException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.NAMING_VIOLATION );
+        }
+
+        assertTrue( "objectClass should still be in the registry after move failure", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+    }
+
+
+    @Test
+    public void testMoveObjectClassToComparatorContainer() throws NamingException
+    {
+        testAddObjectClass();
+        
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        LdapDN newdn = new LdapDN( "ou=comparators,cn=apachemeta" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        try
+        {
+            getSchemaContext( service ).rename( dn, newdn );
+            fail( "should not be able to move a objectClass into comparators container" );
+        }
+        catch( LdapInvalidNameException e ) 
+        {
+            assertEquals( e.getResultCode(), ResultCodeEnum.NAMING_VIOLATION );
+        }
+
+        assertTrue( "objectClass should still be in the registry after move failure", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+    }
+    
+    
+    @Test
+    public void testAddObjectClassToDisabledSchema() throws NamingException
+    {
+        Attributes attrs = new AttributesImpl();
+        Attribute oc = new AttributeImpl( SchemaConstants.OBJECT_CLASS_AT, "top" );
+        oc.add( MetaSchemaConstants.META_TOP_OC );
+        oc.add( MetaSchemaConstants.META_OBJECT_CLASS_OC );
+        attrs.put( oc );
+        attrs.put( MetaSchemaConstants.M_OID_AT, OID );
+        attrs.put( MetaSchemaConstants.M_NAME_AT, NAME);
+        attrs.put( MetaSchemaConstants.M_DESCRIPTION_AT, DESCRIPTION0 );
+        attrs.put( MetaSchemaConstants.M_TYPE_OBJECT_CLASS_AT, "AUXILIARY" );
+        attrs.put( MetaSchemaConstants.M_MUST_AT, "cn" );
+        attrs.put( MetaSchemaConstants.M_MAY_AT, "ou" );
+        
+        LdapDN dn = getObjectClassContainer( "nis" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        getSchemaContext( service ).createSubcontext( dn, attrs );
+        
+        assertFalse( "adding new objectClass to disabled schema should not register it into the registries", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+    }
+
+
+    @Test
+    public void testMoveObjectClassToDisabledSchema() throws NamingException
+    {
+        testAddObjectClass();
+        
+        LdapDN dn = getObjectClassContainer( "apachemeta" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        // nis is inactive by default
+        LdapDN newdn = getObjectClassContainer( "nis" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        getSchemaContext( service ).rename( dn, newdn );
+
+        assertFalse( "objectClass OID should no longer be present", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+    }
+
+
+    @Test
+    public void testMoveObjectClassToEnabledSchema() throws NamingException
+    {
+        testAddObjectClassToDisabledSchema();
+        
+        // nis is inactive by default
+        LdapDN dn = getObjectClassContainer( "nis" );
+        dn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+
+        assertFalse( "objectClass OID should NOT be present when added to disabled nis schema", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+
+        LdapDN newdn = getObjectClassContainer( "apachemeta" );
+        newdn.add( MetaSchemaConstants.M_OID_AT + "=" + OID );
+        
+        getSchemaContext( service ).rename( dn, newdn );
+
+        assertTrue( "objectClass OID should be present when moved to enabled schema", 
+            getObjectClassRegistry().hasObjectClass( OID ) );
+        
+        assertEquals( "objectClass should be in apachemeta schema after move", 
+            getObjectClassRegistry().getSchemaName( OID ), "apachemeta" );
+    }
+}

Propchange: directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaObjectClassHandlerIT.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaSchemaHandlerIT.java
URL: http://svn.apache.org/viewvc/directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaSchemaHandlerIT.java?rev=601657&view=auto
==============================================================================
--- directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaSchemaHandlerIT.java (added)
+++ directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaSchemaHandlerIT.java Thu Dec  6 00:39:23 2007
@@ -0,0 +1,683 @@
+/*
+ *  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.server.core.schema;
+
+
+import org.apache.directory.server.constants.MetaSchemaConstants;
+import org.apache.directory.server.core.DirectoryService;
+import org.apache.directory.server.core.integ.CiRunner;
+import org.apache.directory.server.core.integ.SetupMode;
+import org.apache.directory.server.core.integ.annotations.Mode;
+import static org.apache.directory.server.core.integ.IntegrationUtils.getSchemaContext;
+import org.apache.directory.server.schema.bootstrap.Schema;
+import org.apache.directory.server.schema.registries.AttributeTypeRegistry;
+import org.apache.directory.shared.ldap.exception.LdapNameNotFoundException;
+import org.apache.directory.shared.ldap.exception.LdapOperationNotSupportedException;
+import org.apache.directory.shared.ldap.message.AttributeImpl;
+import org.apache.directory.shared.ldap.message.AttributesImpl;
+import org.apache.directory.shared.ldap.message.ModificationItemImpl;
+import org.apache.directory.shared.ldap.message.ResultCodeEnum;
+import static org.junit.Assert.*;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import javax.naming.NamingException;
+import javax.naming.directory.Attribute;
+import javax.naming.directory.Attributes;
+import javax.naming.directory.DirContext;
+import javax.naming.ldap.LdapContext;
+import java.util.Map;
+
+
+/**
+ * A test case which tests the correct operation of the schema 
+ * entity handler.  
+ *
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ * @version $Rev$
+ */
+@RunWith ( CiRunner.class )
+@Mode ( SetupMode.PRISTINE )
+public class MetaSchemaHandlerIT
+{
+    /** the schema to use for this test: one that is not loaded by default */
+    private static final String TEST_SCHEMA = "nis";
+    /** a test attribute in the test schema: uidNumber in nis schema */
+    private static final String TEST_ATTR_OID = "1.3.6.1.1.1.1.0";
+    /** the name of the dummy schema to test metaSchema adds/deletes with */
+    private static final String DUMMY_SCHEMA = "dummy";
+    
+
+    public static DirectoryService service;
+
+
+    private static AttributeTypeRegistry getAttributeTypeRegistry()
+    {
+        return service.getRegistries().getAttributeTypeRegistry();
+    }
+
+
+    private static Map<String, Schema> getLoadedSchemas()
+    {
+        return service.getRegistries().getLoadedSchemas();
+    }
+
+
+    // -----------------------------------------------------------------------
+    // Schema Add Tests
+    // -----------------------------------------------------------------------
+
+    
+    /**
+     * Tests the addition of a new metaSchema object that is disabled 
+     * on addition and has no dependencies.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testAddDisabledSchemaNoDeps() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
+        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
+        dummySchema.put( "cn", DUMMY_SCHEMA );
+        dummySchema.put( MetaSchemaConstants.M_DISABLED_AT, "TRUE" );
+        schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
+        
+        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+        assertNotNull( schemaRoot.lookup( "cn=" + DUMMY_SCHEMA ) );
+    }
+    
+    
+    /**
+     * Tests the addition of a new metaSchema object that is disabled 
+     * on addition and has dependencies.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testAddDisabledSchemaWithDeps() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
+        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
+        dummySchema.put( "cn", DUMMY_SCHEMA );
+        dummySchema.put( MetaSchemaConstants.M_DISABLED_AT, "TRUE" );
+        dummySchema.put( MetaSchemaConstants.M_DEPENDENCIES_AT, TEST_SCHEMA );
+        dummySchema.get( MetaSchemaConstants.M_DEPENDENCIES_AT ).add( "core" );
+        schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
+        
+        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+        assertNotNull( schemaRoot.lookup( "cn=" + DUMMY_SCHEMA ) );
+    }
+    
+    
+    /**
+     * Tests the rejection of a new metaSchema object that is disabled 
+     * on addition and has missing dependencies.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testRejectDisabledSchemaAddWithMissingDeps() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
+        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
+        dummySchema.put( "cn", DUMMY_SCHEMA );
+        dummySchema.put( MetaSchemaConstants.M_DISABLED_AT, "TRUE" );
+        dummySchema.put( MetaSchemaConstants.M_DEPENDENCIES_AT, "missing" );
+        dummySchema.get( MetaSchemaConstants.M_DEPENDENCIES_AT ).add( "core" );
+        
+        try
+        {
+            schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
+        } 
+        catch( LdapOperationNotSupportedException e )
+        {
+            assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
+        }
+        
+        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+
+        //noinspection EmptyCatchBlock
+        try
+        {
+            schemaRoot.lookup( "cn=" + DUMMY_SCHEMA );
+            fail( "schema should not be added to schema partition" );
+        }
+        catch( NamingException e )
+        {
+        }
+    }
+    
+    
+    /**
+     * Tests the addition of a new metaSchema object that is enabled 
+     * on addition and has no dependencies.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testAddEnabledSchemaNoDeps() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
+        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
+        dummySchema.put( "cn", DUMMY_SCHEMA );
+        schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
+        
+        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+        assertNotNull( schemaRoot.lookup( "cn=" + DUMMY_SCHEMA ) );
+    }
+    
+    
+    /**
+     * Tests the rejection of a metaSchema object add that is enabled 
+     * on addition yet has disabled dependencies.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testRejectEnabledSchemaAddWithDisabledDeps() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
+        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
+        dummySchema.put( "cn", DUMMY_SCHEMA );
+        dummySchema.put( MetaSchemaConstants.M_DEPENDENCIES_AT, TEST_SCHEMA );
+        
+        try
+        {
+            schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
+            fail( "should not be able to add enabled schema with deps on disabled schemas" );
+        }
+        catch( LdapOperationNotSupportedException e )
+        {
+            assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
+        }
+        
+        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+
+        //noinspection EmptyCatchBlock
+        try
+        {
+            schemaRoot.lookup( "cn=" + DUMMY_SCHEMA );
+            fail( "schema should not be added to schema partition" );
+        }
+        catch( NamingException e )
+        {
+        }
+    }
+
+    
+    // -----------------------------------------------------------------------
+    // Schema Delete Tests
+    // -----------------------------------------------------------------------
+
+    
+    /**
+     * Makes sure we can delete schemas that have no dependents.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testDeleteSchemaNoDependents() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+
+        // add the dummy schema enabled 
+        testAddEnabledSchemaNoDeps();
+        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+        
+        // delete it now
+        schemaRoot.destroySubcontext( "cn=" + DUMMY_SCHEMA );
+        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+    }
+    
+    
+    /**
+     * Makes sure we can NOT delete schemas that have dependents.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testRejectSchemaDeleteWithDependents() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+
+        // add the dummy schema enabled
+        testAddEnabledSchemaNoDeps();
+        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+        
+        // make the nis schema depend on the dummy schema
+        ModificationItemImpl[] mods = new ModificationItemImpl[1];
+        mods[0] = new ModificationItemImpl( DirContext.ADD_ATTRIBUTE,
+                new AttributeImpl( MetaSchemaConstants.M_DEPENDENCIES_AT, DUMMY_SCHEMA ) );
+        schemaRoot.modifyAttributes( "cn=" + TEST_SCHEMA, mods );
+        
+        // attempt to delete it now & it should fail
+        try
+        {
+            schemaRoot.destroySubcontext( "cn=" + DUMMY_SCHEMA );
+            fail( "should not be able to delete a schema with dependents" );
+        }
+        catch ( LdapOperationNotSupportedException e )
+        {
+            assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
+        }
+
+        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+    }
+    
+    
+    /**
+     * Tests the rejection of a new metaSchema object that is enabled 
+     * on addition and missing dependencies.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testRejectEnabledSchemaAddWithMisingDeps() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+
+        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
+        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
+        dummySchema.put( "cn", DUMMY_SCHEMA );
+        dummySchema.put( MetaSchemaConstants.M_DEPENDENCIES_AT, "missing" );
+        
+        try
+        {
+            schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
+            fail( "should not be able to add enabled schema with deps on missing schemas" );
+        }
+        catch( LdapOperationNotSupportedException e )
+        {
+            assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
+        }
+        
+        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+
+        //noinspection EmptyCatchBlock
+        try
+        {
+            schemaRoot.lookup( "cn=" + DUMMY_SCHEMA );
+            fail( "schema should not be added to schema partition" );
+        }
+        catch( NamingException e )
+        {
+        }
+    }
+
+    
+    // -----------------------------------------------------------------------
+    // Enable/Disable Schema Tests
+    // -----------------------------------------------------------------------
+
+    
+    private void enableSchema( String schemaName ) throws NamingException
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+
+        // now enable the test schema
+        ModificationItemImpl[] mods = new ModificationItemImpl[1];
+        Attribute attr = new AttributeImpl( "m-disabled", "FALSE" );
+        mods[0] = new ModificationItemImpl( DirContext.REPLACE_ATTRIBUTE, attr );
+        schemaRoot.modifyAttributes( "cn=" + schemaName, mods );
+    }
+    
+    
+    private void disableSchema( String schemaName ) throws NamingException
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+
+        // now enable the test schema
+        ModificationItemImpl[] mods = new ModificationItemImpl[1];
+        Attribute attr = new AttributeImpl( "m-disabled", "TRUE" );
+        mods[0] = new ModificationItemImpl( DirContext.REPLACE_ATTRIBUTE, attr );
+        schemaRoot.modifyAttributes( "cn=" + schemaName, mods );
+    }
+    
+    
+    /**
+     * Checks to make sure updates enabling a metaSchema object in
+     * the schema partition triggers the loading of that schema into
+     * the global registries.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testEnableSchema() throws Exception
+    {
+        AttributeTypeRegistry atr = getAttributeTypeRegistry();
+        
+        // check that the nis schema is not loaded
+        assertNull( getLoadedSchemas().get( TEST_SCHEMA ) );
+        
+        // double check and make sure an attribute from that schema is 
+        // not in the AttributeTypeRegistry
+        assertFalse( atr.hasAttributeType( TEST_ATTR_OID ) );
+        
+        // now enable the test schema
+        enableSchema( "nis" );
+        
+        // now test that the schema is loaded 
+        assertNotNull( getLoadedSchemas().get( TEST_SCHEMA ) );
+        
+        // double check and make sure the test attribute from the 
+        // test schema is now loaded and present within the attr registry
+        assertTrue( atr.hasAttributeType( TEST_ATTR_OID ) );
+    }
+
+
+    /**
+     * Checks to make sure an attempt to disable a metaSchema fails if 
+     * that schema has dependents which are enabled.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testDisableSchema() throws Exception
+    {
+        // let's enable the test schema
+        testEnableSchema();
+        
+        AttributeTypeRegistry atr = getAttributeTypeRegistry();
+        
+        // check that the nis schema is loaded
+        assertNotNull( getLoadedSchemas().get( TEST_SCHEMA ) );
+        
+        // double check and make sure an attribute from that schema is 
+        // in the AttributeTypeRegistry
+        assertTrue( atr.hasAttributeType( TEST_ATTR_OID ) );
+        
+        // now disable the test schema 
+        disableSchema( "samba" );
+        disableSchema( "nis" );
+        
+        // now test that the schema is NOT loaded 
+        assertNull( getLoadedSchemas().get( TEST_SCHEMA ) );
+        
+        // double check and make sure the test attribute from the test  
+        // schema is now NOT loaded and present within the attr registry
+        assertFalse( atr.hasAttributeType( TEST_ATTR_OID ) );
+    }
+
+    
+    /**
+     * Checks to make sure updates disabling a metaSchema object in
+     * the schema partition triggers the unloading of that schema from
+     * the global registries.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testDisableSchemaWithEnabledDependents() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+
+        // let's enable the test schema and add the dummy schema
+        // as enabled by default and dependends on the test schema
+        
+//      // enables the test schema and samba
+        testEnableSchema(); 
+        
+        // adds enabled dummy schema that depends on the test schema  
+        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
+        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
+        dummySchema.put( "cn", DUMMY_SCHEMA );
+        dummySchema.put( MetaSchemaConstants.M_DEPENDENCIES_AT, TEST_SCHEMA );
+        schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
+        
+        // check that the nis schema is loaded and the dummy schema is loaded
+        assertNotNull( getLoadedSchemas().get( TEST_SCHEMA ) );
+        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+        
+        AttributeTypeRegistry atr = getAttributeTypeRegistry();
+        
+        // double check and make sure an attribute from that schema is 
+        // in the AttributeTypeRegistry
+        assertTrue( atr.hasAttributeType( TEST_ATTR_OID ) );
+        
+        // now try to disable the test schema which should fail 
+        // since it's dependent, the dummy schema, is enabled
+        ModificationItemImpl[] mods = new ModificationItemImpl[1];
+        Attribute attr = new AttributeImpl( "m-disabled", "TRUE" );
+        mods[0] = new ModificationItemImpl( DirContext.REPLACE_ATTRIBUTE, attr );
+        
+        try
+        {
+            schemaRoot.modifyAttributes( "cn=nis", mods );
+            fail( "attempt to disable schema with enabled dependents should fail" );
+        }
+        catch ( LdapOperationNotSupportedException e )
+        {
+            assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
+        }
+        
+        // now test that both schema are still loaded 
+        assertNotNull( getLoadedSchemas().get( TEST_SCHEMA ) );
+        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
+        
+        // double check and make sure the test attribute from the test  
+        // schema is still loaded and present within the attr registry
+        assertTrue( atr.hasAttributeType( TEST_ATTR_OID ) );
+    }
+    
+    
+    // -----------------------------------------------------------------------
+    // Schema Rename Tests
+    // -----------------------------------------------------------------------
+
+
+    /**
+     * Makes sure we can change the name of a schema with entities in it.
+     * Will use the samba schema which comes out of the box and nothing 
+     * depends on.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testSchemaRenameDisabledSchema() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+        schemaRoot.rename( "cn=samba", "cn=foo" );
+        assertNotNull( schemaRoot.lookup( "cn=foo" ) );
+
+        //noinspection EmptyCatchBlock
+        try
+        {
+            schemaRoot.lookup( "cn=samba" );
+            fail( "the samba schema should not be present after a rename to foo" );
+        }
+        catch( LdapNameNotFoundException e )
+        {
+        }
+    }
+
+
+    /**
+     * Makes sure we can NOT change the name of a schema that has dependents.
+     * Will use the nis schema which comes out of the box and has samba as
+     * it's dependent.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testRejectSchemaRenameWithDeps() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+        try
+        {
+            schemaRoot.rename( "cn=nis", "cn=foo" );
+            fail( "should not be able to rename nis which has samba as it's dependent" );
+        }
+        catch ( LdapOperationNotSupportedException e )
+        {
+            assertEquals( ResultCodeEnum.UNWILLING_TO_PERFORM, e.getResultCode() );
+        }
+        
+        assertNotNull( schemaRoot.lookup( "cn=nis" ) );
+
+        //noinspection EmptyCatchBlock
+        try
+        {
+            schemaRoot.lookup( "cn=foo" );
+            fail( "the foo schema should not be present after rejecting the rename" );
+        }
+        catch( LdapNameNotFoundException e )
+        {
+        }
+    }
+
+
+    /**
+     * Makes sure we can change the name of a schema with entities in it.
+     * Will use the samba schema which comes out of the box and nothing 
+     * depends on.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testSchemaRenameEnabledSchema() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+        enableSchema( "samba" );
+        assertTrue( getAttributeTypeRegistry().hasAttributeType( "sambaNTPassword" ) );
+        assertEquals( "samba", getAttributeTypeRegistry().getSchemaName( "sambaNTPassword" ) );
+        
+        schemaRoot.rename( "cn=samba", "cn=foo" );
+        assertNotNull( schemaRoot.lookup( "cn=foo" ) );
+        assertTrue( getAttributeTypeRegistry().hasAttributeType( "sambaNTPassword" ) );
+        assertEquals( "foo", getAttributeTypeRegistry().getSchemaName( "sambaNTPassword" ) );
+
+        //noinspection EmptyCatchBlock
+        try
+        {
+            schemaRoot.lookup( "cn=samba" );
+            fail( "the samba schema should not be present after a rename to foo" );
+        }
+        catch( LdapNameNotFoundException e )
+        {
+        }
+    }
+
+
+    // -----------------------------------------------------------------------
+    // Dependency Modify Tests
+    // -----------------------------------------------------------------------
+
+
+    /**
+     * Checks to make sure the addition of an undefined schema to the dependencies 
+     * of an existing schema fail with an UNWILLING_TO_PERFORM result code.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testRejectAddBogusDependency() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+
+        ModificationItemImpl[] mods = new ModificationItemImpl[1];
+        Attribute attr = new AttributeImpl( "m-dependencies", "bogus" );
+        mods[0] = new ModificationItemImpl( DirContext.ADD_ATTRIBUTE, attr );
+        
+        try
+        {
+            schemaRoot.modifyAttributes( "cn=" + TEST_SCHEMA, mods );
+            fail( "Should not be able to add bogus dependency to schema" );
+        }
+        catch ( LdapOperationNotSupportedException e )
+        {
+            assertEquals( ResultCodeEnum.UNWILLING_TO_PERFORM, e.getResultCode() );
+        }
+    }
+
+
+    /**
+     * Checks to make sure the addition of an defined yet disabled schema to the 
+     * dependencies of an existing enabled schema fails with an UNWILLING_TO_PERFORM 
+     * result code.  You must enable the dependency to add it or disable the schema 
+     * depending on it to add it.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testRejectAddOfDisabledDependencyToEnabledSchema() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+        enableSchema( TEST_SCHEMA );
+        ModificationItemImpl[] mods = new ModificationItemImpl[1];
+        Attribute attr = new AttributeImpl( "m-dependencies", "mozilla" );
+        mods[0] = new ModificationItemImpl( DirContext.ADD_ATTRIBUTE, attr );
+        
+        try
+        {
+            schemaRoot.modifyAttributes( "cn=" + TEST_SCHEMA, mods );
+            fail( "Should not be able to add disabled dependency to schema" );
+        }
+        catch ( LdapOperationNotSupportedException e )
+        {
+            assertEquals( ResultCodeEnum.UNWILLING_TO_PERFORM, e.getResultCode() );
+        }
+    }
+
+
+    /**
+     * Checks to make sure the addition of an defined yet disabled schema to the 
+     * dependencies of an existing disabled schema succeeds. 
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testAddOfDisabledDependencyToDisabledSchema() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+        ModificationItemImpl[] mods = new ModificationItemImpl[1];
+        Attribute attr = new AttributeImpl( "m-dependencies", "mozilla" );
+        mods[0] = new ModificationItemImpl( DirContext.ADD_ATTRIBUTE, attr );
+        schemaRoot.modifyAttributes( "cn=" + TEST_SCHEMA, mods );
+        Attributes attrs = schemaRoot.getAttributes( "cn=" + TEST_SCHEMA );
+        Attribute dependencies = attrs.get( "m-dependencies" );
+        assertTrue( dependencies.contains( "mozilla" ) );
+    }
+
+
+    /**
+     * Checks to make sure the addition of an defined yet enabled schema to the 
+     * dependencies of an existing disabled schema succeeds.
+     *
+     * @throws Exception on error
+     */
+    @Test
+    public void testAddOfEnabledDependencyToDisabledSchema() throws Exception
+    {
+        LdapContext schemaRoot = getSchemaContext( service );
+        ModificationItemImpl[] mods = new ModificationItemImpl[1];
+        Attribute attr = new AttributeImpl( "m-dependencies", "java" );
+        mods[0] = new ModificationItemImpl( DirContext.ADD_ATTRIBUTE, attr );
+        schemaRoot.modifyAttributes( "cn=" + TEST_SCHEMA, mods );
+        Attributes attrs = schemaRoot.getAttributes( "cn=" + TEST_SCHEMA );
+        Attribute dependencies = attrs.get( "m-dependencies" );
+        assertTrue( dependencies.contains( "java" ) );
+    }
+}

Propchange: directory/apacheds/branches/bigbang/core-integ/src/test/java/org/apache/directory/server/core/schema/MetaSchemaHandlerIT.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message