testall.java

来自「jsr170接口的java实现。是个apache的开源项目。」· Java 代码 · 共 580 行 · 第 1/2 页

/*
 * 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.jackrabbit.core.nodetype.xml;

import junit.framework.AssertionFailedError;
import junit.framework.TestCase;

import org.apache.jackrabbit.api.JackrabbitNodeTypeManager;
import org.apache.jackrabbit.core.TestRepository;
import org.apache.jackrabbit.core.nodetype.InvalidNodeTypeDefException;
import org.apache.jackrabbit.core.nodetype.NodeDef;
import org.apache.jackrabbit.core.nodetype.NodeTypeDef;
import org.apache.jackrabbit.core.nodetype.PropDef;
import org.apache.jackrabbit.core.value.InternalValue;
import org.apache.jackrabbit.name.NamespaceResolver;
import org.apache.jackrabbit.name.QName;

import javax.jcr.NamespaceException;
import javax.jcr.NamespaceRegistry;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.version.OnParentVersionAction;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

/**
 * Test cases for reading and writing node type definition files.
 */
public class TestAll extends TestCase {

    /** The dummy test namespace. */
    private static final String TEST_NAMESPACE = "test-namespace";

    /** Name of the include test node type definition file. */
    private static final String TEST_NODETYPES =
        "org/apache/jackrabbit/core/nodetype/xml/test_nodetypes.xml";

    /** Name of the xml nodetype file for import and namespace registration. */
    private static final String TEST_NS_XML_NODETYPES =
        "test_ns_xml_nodetypes.xml";

    /** Name of the cnd nodetype file for import and namespace registration. */
    private static final String TEST_NS_CND_NODETYPES =
        "test_ns_cnd_nodetypes.cnd";

    /** Test node types definitions. */
    private NodeTypeDef[] types;

    /** Registry for the test namespaces. */
    private NamespaceRegistry registry;

    /**
     * Initializes the node type formatter tests.
     *
     * @throws Exception on initialization errors
     */
    protected void setUp() throws Exception {
        InputStream xml =
            getClass().getClassLoader().getResourceAsStream(TEST_NODETYPES);

        types = NodeTypeReader.read(xml);

        registry = new SimpleNamespaceRegistry();
        registry.registerNamespace("test", TEST_NAMESPACE);
    }

    /**
     * Returns the named node type definition. If the node type does not
     * exist, an assertion failure is generated.
     *
     * @param name node type name
     * @return node type definition
     */
    private NodeTypeDef getNodeType(String name) {
        QName qname = new QName(TEST_NAMESPACE, name);
        for (int i = 0; i < types.length; i++) {
            if (qname.equals(types[i].getName())) {
                return types[i];
            }
        }
        throw new AssertionFailedError("Node type " + name + " does not exist");
    }

    /**
     * Returns the named property definition from the named node type
     * definition. If either of the definitions do not exist, an assertion
     * failure is generated.
     * <p>
     * If the given property name is <code>null</code>, then the residual
     * property definition (if one exists) is returned.
     *
     * @param typeName node type name
     * @param propertyName property name, or <code>null</code>
     * @return property definition
     */
    private PropDef getProperty(String typeName, String propertyName) {
        QName name;
        if (propertyName != null) {
            name = new QName(TEST_NAMESPACE, propertyName);
        } else {
            name = PropDef.ANY_NAME;
        }

        NodeTypeDef def = getNodeType(typeName);
        PropDef[] defs = def.getPropertyDefs();
        for (int i = 0; i < defs.length; i++) {
            if (name.equals(defs[i].getName())) {
                return defs[i];
            }
        }

        throw new AssertionFailedError(
                "Property " + propertyName + " does not exist");
    }

    /**
     * Returns the string value of the identified property default value.
     *
     * @param def property definition
     * @param index default value index
     * @return default value
     */
    private String getDefaultValue(PropDef def, int index) {
        try {
            InternalValue[] values = def.getDefaultValues();
            NamespaceResolver resolver = new AdditionalNamespaceResolver(registry);
            return values[index].toJCRValue(resolver).getString();
        } catch (RepositoryException e) {
            throw new AssertionFailedError(e.getMessage());
        }
    }

    /**
     * Returns the named child node definition from the named node type
     * definition. If either of the definitions do not exist, an assertion
     * failure is generated.
     *
     * @param typeName node type name
     * @param nodeName child node name
     * @return child node definition
     */
    private NodeDef getChildNode(String typeName, String nodeName) {
        QName name = new QName(TEST_NAMESPACE, nodeName);

        NodeTypeDef def = getNodeType(typeName);
        NodeDef[] defs = def.getChildNodeDefs();
        for (int i = 0; i < defs.length; i++) {
            if (name.equals(defs[i].getName())) {
                return defs[i];
            }
        }

        throw new AssertionFailedError(
                "Child node " + nodeName + " does not exist");
    }

    /**
     * Test for reading a node type definition file. The test file
     * has already been read during the test setup, so this method
     * just verifies the number of node types.
     */
    public void testRead() {
        assertEquals("number of node types", 6, types.length);
    }

    /** Test for the empty node type. */
    public void testEmptyNodeType() {
        NodeTypeDef def = getNodeType("emptyNodeType");
        assertNotNull("emptyNodeType exists", def);
        assertEquals("emptyNodeType mixin",
                false, def.isMixin());
        assertEquals("emptyNodeType hasOrderableChildNodes",
                false, def.hasOrderableChildNodes());
        assertEquals("emptyNodeType primaryItemName",
                null, def.getPrimaryItemName());
        assertEquals("emptyNodeType childNodeDefs",
                0, def.getChildNodeDefs().length);
        assertEquals("emptyNodeType propertyDefs",
                0, def.getPropertyDefs().length);
    }

    /** Test for the <code>mixin</code> node type attribute. */
    public void testMixinNodeType() {
        NodeTypeDef def = getNodeType("mixinNodeType");
        assertEquals("mixinNodeType mixin",
                true, def.isMixin());
    }

    /** Test for the <code>hasOrderableChildNodes</code> node type attribute. */
    public void testOrderedNodeType() {
        NodeTypeDef def = getNodeType("orderedNodeType");
        assertEquals("orderedNodeType hasOrderableChildNodes",
                true, def.hasOrderableChildNodes());
    }

    /** Test for node type item definitions. */
    public void testItemNodeType() {
        NodeTypeDef def = getNodeType("itemNodeType");
        assertEquals("itemNodeType primaryItemName",
                new QName(TEST_NAMESPACE, "emptyItem"),
                def.getPrimaryItemName());
        assertEquals("itemNodeType propertyDefs",
                10, def.getPropertyDefs().length);
        PropDef pdef = getProperty("itemNodeType", null);
        assertTrue("itemNodeType wildcard property", pdef.definesResidual());
    }

    /** Test for namespace registration on node type import. */
    public void testImportXMLNodeTypes() throws Exception {
        Session session = TestRepository.getInstance().login();
        try {
            session.getNamespacePrefix("test-namespace2");
            // Ignore test case, node type and namespace already registered
        } catch (NamespaceException e1) {
            // Namespace testns2 not yet registered
            JackrabbitNodeTypeManager ntm = (JackrabbitNodeTypeManager)
                session.getWorkspace().getNodeTypeManager();
            ntm.registerNodeTypes(
                    TestAll.class.getResourceAsStream(TEST_NS_XML_NODETYPES),
                    JackrabbitNodeTypeManager.TEXT_XML);
            try {
                session.getNamespacePrefix("test-namespace2");
            } catch (NamespaceException e2) {
                fail("xml test2 namespace not registered");
            }
        } finally {
            session.logout();
        }
    }

    /** Test for namespace registration on node type import. */
    public void testImportCNDNodeTypes() throws Exception {
        Session session = TestRepository.getInstance().login();
        try {
            session.getNamespacePrefix("test-namespace3");
            // Ignore test case, node type and namespace already registered
        } catch (NamespaceException e1) {
            JackrabbitNodeTypeManager ntm = (JackrabbitNodeTypeManager)
                session.getWorkspace().getNodeTypeManager();
            ntm.registerNodeTypes(
                    TestAll.class.getResourceAsStream(TEST_NS_CND_NODETYPES),
                    JackrabbitNodeTypeManager.TEXT_X_JCR_CND);
            try {
                session.getNamespacePrefix("test-namespace3");
            } catch (NamespaceException e2) {
                fail("cnd test3 namespace not registered");
            }
        } finally {
            session.logout();
        }
    }

    /** Test for the empty item definition. */
    public void testEmptyItem() {
        PropDef def = getProperty("itemNodeType", "emptyItem");
        assertEquals("emptyItem autoCreate",
                false, def.isAutoCreated());
        assertEquals("emptyItem mandatory",
                false, def.isMandatory());
        assertEquals("emptyItem onParentVersion",
                OnParentVersionAction.IGNORE, def.getOnParentVersion());
        assertEquals("emptyItem protected",
                false, def.isProtected());
    }

    /** Test for the <code>autoCreated</code> item definition attribute. */
    public void testAutoCreateItem() {
        PropDef def = getProperty("itemNodeType", "autoCreatedItem");
        assertEquals("autoCreatedItem autoCreated",
                true, def.isAutoCreated());
    }