testall.java

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

    /** Test for the <code>mandatory</code> item definition attribute. */
    public void testMandatoryItem() {
        PropDef def = getProperty("itemNodeType", "mandatoryItem");
        assertEquals("mandatoryItem mandatory",
                true, def.isMandatory());
    }

    /** Test for the <code>copy</code> parent version action. */
    public void testCopyItem() {
        PropDef def = getProperty("itemNodeType", "copyItem");
        assertEquals("copyItem onParentVersion",
                OnParentVersionAction.COPY, def.getOnParentVersion());
    }

    /** Test for the <code>version</code> parent version action. */
    public void testVersionItem() {
        PropDef def = getProperty("itemNodeType", "versionItem");
        assertEquals("versionItem onParentVersion",
                OnParentVersionAction.VERSION, def.getOnParentVersion());
    }

    /** Test for the <code>initialize</code> parent version action. */
    public void testInitializeItem() {
        PropDef def = getProperty("itemNodeType", "initializeItem");
        assertEquals("initializeItem onParentVersion",
                OnParentVersionAction.INITIALIZE, def.getOnParentVersion());
    }

    /** Test for the <code>compute</code> parent version action. */
    public void testComputeItem() {
        PropDef def = getProperty("itemNodeType", "computeItem");
        assertEquals("computeItem onParentVersion",
                OnParentVersionAction.COMPUTE, def.getOnParentVersion());
    }

    /** Test for the <code>abort</code> parent version action. */
    public void testAbortItem() {
        PropDef def = getProperty("itemNodeType", "abortItem");
        assertEquals("abortItem onParentVersion",
                OnParentVersionAction.ABORT, def.getOnParentVersion());
    }

    /** Test for the <code>protected</code> item definition attribute. */
    public void testProtectedItem() {
        PropDef def = getProperty("itemNodeType", "protectedItem");
        assertEquals("protectedItem protected",
                true, def.isProtected());
    }

    /** Test for node type property definitions. */
    public void testPropertyNodeType() {
        NodeTypeDef def = getNodeType("propertyNodeType");
        assertEquals("propertyNodeType propertyDefs",
                11, def.getPropertyDefs().length);
    }

    /** Test for the empty property definition. */
    public void testEmptyProperty() {
        PropDef def = getProperty("propertyNodeType", "emptyProperty");
        assertEquals("emptyProperty requiredType",
                PropertyType.UNDEFINED, def.getRequiredType());
        assertEquals("emptyProperty multiple",
                false, def.isMultiple());
        assertEquals("emptyProperty defaultValues",
                0, def.getDefaultValues().length);
        assertEquals("emptyProperty valueConstraints",
                0, def.getValueConstraints().length);
    }

    /** Test for the <code>binary</code> property definition type. */
    public void testBinaryProperty() {
        PropDef def = getProperty("propertyNodeType", "binaryProperty");
        assertEquals("binaryProperty requiredType",
                PropertyType.BINARY, def.getRequiredType());
        assertEquals("binaryProperty valueConstraints",
                1, def.getValueConstraints().length);
        assertEquals("binaryProperty valueConstraints[0]",
                "[0,)", (def.getValueConstraints())[0].getDefinition());
        assertEquals("binaryProperty defaultValues",
                0, def.getDefaultValues().length);
    }

    /** Test for the <code>boolean</code> property definition type. */
    public void testBooleanProperty() {
        PropDef def = getProperty("propertyNodeType", "booleanProperty");
        assertEquals("booleanProperty requiredType",
                PropertyType.BOOLEAN, def.getRequiredType());
        assertEquals("booleanProperty valueConstraints",
                2, def.getValueConstraints().length);
        assertEquals("booleanProperty valueConstraints[0]",
                "true", (def.getValueConstraints())[0].getDefinition());
        assertEquals("booleanProperty valueConstraints[1]",
                "false", (def.getValueConstraints())[1].getDefinition());
        assertEquals("booleanProperty defaultValues",
                1, def.getDefaultValues().length);
        assertEquals("booleanProperty defaultValues[0]",
                "true", getDefaultValue(def, 0));
    }

    /** Test for the <code>date</code> property definition type. */
    public void testDateProperty() {
        PropDef def = getProperty("propertyNodeType", "dateProperty");
        assertEquals("dateProperty requiredType",
                PropertyType.DATE, def.getRequiredType());
        assertEquals("dateProperty valueConstraints",
                1, def.getValueConstraints().length);
        assertEquals("dateProperty valueConstraints[0]",
                "[2005-01-01T00:00:00.000Z,2006-01-01T00:00:00.000Z)",
                (def.getValueConstraints())[0].getDefinition());
        assertEquals("dateProperty defaultValues",
                1, def.getDefaultValues().length);
        assertEquals("dateProperty defaultValues[0]",
                "2005-01-01T00:00:00.000Z", getDefaultValue(def, 0));
    }

    /** Test for the <code>double</code> property definition type. */
    public void testDoubleProperty() {
        PropDef def = getProperty("propertyNodeType", "doubleProperty");
        assertEquals("doubleProperty requiredType",
                PropertyType.DOUBLE, def.getRequiredType());
        assertEquals("doubleProperty valueConstraints",
                3, def.getValueConstraints().length);
        assertEquals("doubleProperty valueConstraints[0]",
                "[,0.0)", (def.getValueConstraints())[0].getDefinition());
        assertEquals("doubleProperty valueConstraints[1]",
                "(1.0,2.0)", (def.getValueConstraints())[1].getDefinition());
        assertEquals("doubleProperty valueConstraints[2]",
                "(3.0,]", (def.getValueConstraints())[2].getDefinition());
        assertEquals("doubleProperty defaultValues",
                1, def.getDefaultValues().length);
        assertEquals("doubleProperty defaultValues[0]",
                "1.5", getDefaultValue(def, 0));
    }

    /** Test for the <code>long</code> property definition type. */
    public void testLongProperty() {
        PropDef def = getProperty("propertyNodeType", "longProperty");
        assertEquals("longProperty requiredType",
                PropertyType.LONG, def.getRequiredType());
        assertEquals("longProperty valueConstraints",
                3, def.getValueConstraints().length);
        assertEquals("longProperty valueConstraints[0]",
                "(-10,0]", (def.getValueConstraints())[0].getDefinition());
        assertEquals("longProperty valueConstraints[1]",
                "[1,2]", (def.getValueConstraints())[1].getDefinition());
        assertEquals("longProperty valueConstraints[2]",
                "[10,100)", (def.getValueConstraints())[2].getDefinition());
        assertEquals("longProperty defaultValues",
                1, def.getDefaultValues().length);
        assertEquals("longProperty defaultValues[0]",
                "25", getDefaultValue(def, 0));
    }

    /** Test for the <code>name</code> property definition type. */
    public void testNameProperty() {
        PropDef def = getProperty("propertyNodeType", "nameProperty");
        assertEquals("nameProperty requiredType",
                PropertyType.NAME, def.getRequiredType());
        assertEquals("nameProperty valueConstraints",
                1, def.getValueConstraints().length);
        assertEquals("nameProperty valueConstraints[0]",
                "test:testName",
                (def.getValueConstraints())[0].getDefinition());
        assertEquals("nameProperty defaultValues",
                1, def.getDefaultValues().length);
        assertEquals("nameProperty defaultValues[0]",
                "test:testName", getDefaultValue(def, 0));
    }

    /** Test for the <code>path</code> property definition type. */
    public void testPathProperty() {
        PropDef def = getProperty("propertyNodeType", "pathProperty");
        assertEquals("pathProperty requiredType",
                PropertyType.PATH, def.getRequiredType());
        assertEquals("pathProperty valueConstraints",
                1, def.getValueConstraints().length);
        assertEquals("pathProperty valueConstraints[0]",
                "/test:testPath",
                (def.getValueConstraints())[0].getDefinition());
        assertEquals("pathProperty defaultValues",
                0, def.getDefaultValues().length);
    }

    /** Test for the <code>reference</code> property definition type. */
    public void testReferenceProperty() {
        PropDef def = getProperty("propertyNodeType", "referenceProperty");
        assertEquals("referenceProperty requiredType",
                PropertyType.REFERENCE, def.getRequiredType());
        assertEquals("referenceProperty valueConstraints",
                1, def.getValueConstraints().length);
        assertEquals("referenceProperty valueConstraints[0]",
                "test:testType",
                (def.getValueConstraints())[0].getDefinition());
        assertEquals("referenceProperty defaultValues",
                0, def.getDefaultValues().length);
    }

    /** Test for the <code>string</code> property definition type. */
    public void testStringProperty() {
        PropDef def = getProperty("propertyNodeType", "stringProperty");
        assertEquals("stringProperty requiredType",
                PropertyType.STRING, def.getRequiredType());
        assertEquals("stringProperty valueConstraints",
                1, def.getValueConstraints().length);
        assertEquals("stringProperty valueConstraints[0]",
                "bananas?",
                (def.getValueConstraints())[0].getDefinition());
        assertEquals("stringProperty defaultValues",
                2, def.getDefaultValues().length);
        assertEquals("stringProperty defaultValues[0]",
                "banana", getDefaultValue(def, 0));
        assertEquals("stringProperty defaultValues[1]",
                "bananas", getDefaultValue(def, 1));
    }

    /** Test for the <code>multiple</code> property definition attribute. */
    public void testMultipleProperty() {
        PropDef def = getProperty("propertyNodeType", "multipleProperty");
        assertEquals("multipleProperty multiple",
                true, def.isMultiple());
    }

    /** Test for node type child node definitions. */
    public void testChildNodeType() {
        NodeTypeDef def = getNodeType("childNodeType");
        assertEquals("childNodeType childNodeDefs",
                4, def.getChildNodeDefs().length);
    }

    /** Test for the empty child node definition. */
    public void testEmptyNode() {
        NodeDef def = getChildNode("childNodeType", "emptyNode");
        assertEquals("emptyNode allowsSameNameSiblings",
                false, def.allowsSameNameSiblings());
        assertEquals("emptyNode defaultPrimaryType",
                null, def.getDefaultPrimaryType());
    }

    /** Test for the <code>allowsSameNameSiblings</code> child node attribute. */
    public void testSiblingNode() {
        NodeDef def = getChildNode("childNodeType", "siblingNode");
        assertEquals("siblingNode allowsSameNameSiblings",
                true, def.allowsSameNameSiblings());
    }

    /** Test for the <code>defaultPrimaryType</code> child node attribute. */
    public void testDefaultTypeNode() {
        NodeDef def = getChildNode("childNodeType", "defaultTypeNode");
        assertEquals("defaultTypeNode defaultPrimaryType",
                new QName(TEST_NAMESPACE, "testType"),
                def.getDefaultPrimaryType());
    }

    /** Test for the <code>requiredPrimaryTypes</code> child node attributes. */
    public void testRequiredTypeNode() {
        NodeDef def = getChildNode("childNodeType", "requiredTypeNode");
        assertEquals("requiredTypeNode requiredPrimaryTypes",
                2, def.getRequiredPrimaryTypes().length);
        QName[] types = def.getRequiredPrimaryTypes();
        Arrays.sort(types);
        assertEquals("requiredTypeNode requiredPrimaryTypes[0]",
                new QName(TEST_NAMESPACE, "baseType"), types[0]);
        assertEquals("requiredTypeNode requiredPrimaryTypes[1]",
                new QName(TEST_NAMESPACE, "testType"), types[1]);
    }

    /**
     * Test for writing a node type definition file. Writing is tested
     * by writing and re-reading the test node types using an internal
     * byte array. The resulting node type map is then compared to the
     * original test node types.
     *
     * @throws IOException on IO errors
     * @throws RepositoryException on repository errors
     */
    public void testWrite() throws IOException, RepositoryException {
        try {
            ByteArrayOutputStream xml = new ByteArrayOutputStream();
            NodeTypeWriter.write(xml, types, registry);
            byte[] bytes = xml.toByteArray();
            NodeTypeDef[] output =
                NodeTypeReader.read(new ByteArrayInputStream(bytes));
            assertTrue("write output", Arrays.equals(types, output));
        } catch (InvalidNodeTypeDefException e) {
            fail(e.getMessage());
        }
    }

}