iattributetest.java

是高效开发JAVA的XML工具

    }

    public void testIsPublicVisibility_false() {
        IClass cls = (IClass)getElement(project.getOwnedElements(), "Class0");
        IAttribute attr = (IAttribute)getElement(cls.getAttributes(), "attribute3");
        assertFalse(attr.isPublicVisibility());
    }

    public void testIsPublicVisibility_true_ASSOCIATION_END() {
        IClass cls = (IClass)getElement(project.getOwnedElements(), "Class4");
        IAttribute attr = (IAttribute)getElement(cls.getAttributes(), "class5");
        assertTrue(attr.isPublicVisibility());
    }

    public void testIsPackageVisibility_true() {
        IClass cls = (IClass)getElement(project.getOwnedElements(), "Class0");
        IAttribute attr = (IAttribute)getElement(cls.getAttributes(), "attribute3");
        assertTrue(attr.isPackageVisibility());
    }

    public void testIsPackageVisibility_false() {
        IClass cls = (IClass)getElement(project.getOwnedElements(), "Class0");
        IAttribute attr = (IAttribute)getElement(cls.getAttributes(), "attribute0");
        assertFalse(attr.isPackageVisibility());
    }

    public void testIsPackageVisibility_true_ASSOCIATION_END() {
        IClass cls = (IClass)getElement(project.getOwnedElements(), "Class5");
        IAttribute attr = (IAttribute)getElement(cls.getAttributes(), "class4");
        assertTrue(attr.isPackageVisibility());
    }

    public void testSetTypeWithNullParameter() throws ClassNotFoundException {
    	IClass cls = (IClass)getElement(project.getOwnedElements(), "Class0");
        IAttribute attr = (IAttribute)getElement(cls.getAttributes(), "attribute0");
		try {
    		TransactionManager.beginTransaction();
    		attr.setType(null);
            TransactionManager.endTransaction();
            fail();
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		assertEquals(e.getKey(), InvalidEditingException.PARAMETER_ERROR_KEY);
        }
	}

    public void testSetType() throws ClassNotFoundException {
    	IClass cls = (IClass)getElement(project.getOwnedElements(), "Class0");
        IAttribute attr = (IAttribute)getElement(cls.getAttributes(), "attribute0");
    	IClass cls2 = (IClass)getElement(project.getOwnedElements(), "Class2");
    	try {
    		TransactionManager.beginTransaction();
    		attr.setType(cls2);
            TransactionManager.endTransaction();
            assertEquals("Class2", attr.getType().getName());
            assertEquals("Class2", attr.getTypeExpression());
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		fail();
        }
    }

    public void testSetTypeExpressionWithNullParameter() throws ClassNotFoundException {
    	IClass cls = (IClass)getElement(project.getOwnedElements(), "Class0");
        IAttribute attr = (IAttribute)getElement(cls.getAttributes(), "attribute0");
		try {
    		TransactionManager.beginTransaction();
    		attr.setTypeExpression(null);
            TransactionManager.endTransaction();
            fail();
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		assertEquals(e.getKey(), InvalidEditingException.PARAMETER_ERROR_KEY);
        }
	}

    public void testSetTypeExpression() throws ClassNotFoundException {
    	IClass cls = (IClass)getElement(project.getOwnedElements(), "Class0");
        IAttribute attr = (IAttribute)getElement(cls.getAttributes(), "attribute0");
		try {
    		TransactionManager.beginTransaction();
    		attr.setTypeExpression("Class5");
            TransactionManager.endTransaction();
            assertEquals("Class5", attr.getType().getName());
            assertEquals("Class5", attr.getTypeExpression());
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		fail();
        }
	}

    public void testSetTypeExpressionWithMissingClass() throws ClassNotFoundException {
    	IClass cls = (IClass)getElement(project.getOwnedElements(), "Class0");
        IAttribute attr = (IAttribute)getElement(cls.getAttributes(), "attribute0");
		try {
    		TransactionManager.beginTransaction();
    		attr.setTypeExpression("Class100");
            TransactionManager.endTransaction();
            fail();
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		assertEquals(e.getKey(), InvalidEditingException.NO_TARGET_CLASSIFIER_KEY);
        }
	}

    public void testSetInitialValueWithNullParameter() throws ClassNotFoundException {
    	IClass cls = (IClass)getElement(project.getOwnedElements(), "Class0");
        IAttribute attr = (IAttribute)getElement(cls.getAttributes(), "attribute0");
		try {
    		TransactionManager.beginTransaction();
    		attr.setInitialValue(null);
            TransactionManager.endTransaction();
            assertEquals("", attr.getInitialValue());
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		fail();
        }
	}

    public void testSetInitialValueForAttribute() throws ClassNotFoundException {
        setInitialValueFor(getAttribute0InClass0());
	}

    public void testSetInitialValueForAssociationEnd() throws ClassNotFoundException {
        setInitialValueFor(getAssociationEndNamedClass1());
	}

    public void testSetChangeableForAttribute() throws ClassNotFoundException {
    	setChangeableFor(getAttribute0InClass0());
    }

    public void testSetChangeableForAssociationEnd() throws ClassNotFoundException {
        setChangeableFor(getAssociationEndNamedClass1());
    }

    public void testSetAggregationForAttribute() throws ClassNotFoundException {
    	setAggregationFor(getAttribute0InClass0());
    }

    public void testSetAggregationForAssociationEnd() throws ClassNotFoundException {
    	setAggregationFor(getAssociationEndNamedClass1());
    }

    public void testSetCompositeForAttribute() throws ClassNotFoundException {
    	setCompositeFor(getAttribute0InClass0());
    }

    public void testSetCompositeForAssociationEnd() throws ClassNotFoundException {
    	setCompositeFor(getAssociationEndNamedClass1());
    }

    public void testSetStaticForAttribute() throws ClassNotFoundException {
    	setStaticFor(getAttribute0InClass0());
    }

    public void testSetStaticForAssociationEnd() throws ClassNotFoundException {
    	setStaticFor(getAssociationEndNamedClass1());
    }

    public void testSetMultiplicityWithNullParameter() throws ClassNotFoundException {
    	IAttribute attr = getAssociationEndNamedClass1();
		try {
    		TransactionManager.beginTransaction();
    		attr.setMultiplicity(null);
            TransactionManager.endTransaction();
            fail();
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		assertEquals(e.getKey(), InvalidEditingException.PARAMETER_ERROR_KEY);
        }
	}

    public void testSetMultiplicityForAssociationEnd() throws ClassNotFoundException {
    	IAttribute attr = getAssociationEndNamedClass1();
    	//"0..*"
		try {
    		TransactionManager.beginTransaction();
    		attr.setMultiplicity(new int[][] {{0, IMultiplicityRange.UNLIMITED}});
            TransactionManager.endTransaction();
            assertNotNull(attr.getMultiplicity());
            assertTrue(attr.getMultiplicity().length == 1);
            assertTrue(0 == attr.getMultiplicity()[0].getLower());
            assertTrue(IMultiplicityRange.UNLIMITED == attr.getMultiplicity()[0].getUpper());
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		fail();
        }
    	//"*"
    	try {
    		TransactionManager.beginTransaction();
    		attr.setMultiplicity(new int[][] {{IMultiplicityRange.UNLIMITED}});
            TransactionManager.endTransaction();
            assertNotNull(attr.getMultiplicity());
            assertTrue(attr.getMultiplicity().length == 1);
            assertTrue(IMultiplicityRange.UNLIMITED == attr.getMultiplicity()[0].getLower());
            assertTrue(IMultiplicityRange.UNLIMITED == attr.getMultiplicity()[0].getUpper());
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		fail();
        }
    	//"0..6"
    	try {
    		TransactionManager.beginTransaction();
    		attr.setMultiplicity(new int[][] {{0, 6}});
            TransactionManager.endTransaction();
            assertNotNull(attr.getMultiplicity());
            assertTrue(attr.getMultiplicity().length == 1);
            assertTrue(0 == attr.getMultiplicity()[0].getLower());
            assertTrue(6 == attr.getMultiplicity()[0].getUpper());
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		fail();
        }
    	//"1,3,5,7,9,0..6"
    	try {
    		TransactionManager.beginTransaction();
    		attr.setMultiplicity(new int[][] {{1},{3},{5},{7}, {9},{0,6}});
            TransactionManager.endTransaction();
            assertNotNull(attr.getMultiplicity());
            assertTrue(attr.getMultiplicity().length == 6);
            assertTrue(1 == attr.getMultiplicity()[0].getLower());
            assertTrue(1 == attr.getMultiplicity()[0].getUpper());
            assertTrue(0 == attr.getMultiplicity()[5].getLower());
            assertTrue(6 == attr.getMultiplicity()[5].getUpper());
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		fail();
        }
	}

    public void testSetIllealMultiplicityForAssociationEnd() throws ClassNotFoundException {
        IAttribute attr = getAssociationEndNamedClass1();
        try {
    		TransactionManager.beginTransaction();
    		attr.setMultiplicity(new int[][] {{0, 6, 9}});
            TransactionManager.endTransaction();
            fail();
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		assertEquals(e.getKey(), InvalidEditingException.INVALID_MULTIPLICITY_KEY);
        }

    	try {
    		TransactionManager.beginTransaction();
    		attr.setMultiplicity(new int[][] {{-5, 5}});
            TransactionManager.endTransaction();
            fail();
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		assertEquals(e.getKey(), InvalidEditingException.INVALID_MULTIPLICITY_KEY);
        }

    	try {
    		TransactionManager.beginTransaction();
    		attr.setMultiplicity(new int[][] {{0, -5}});
            TransactionManager.endTransaction();
            fail();
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		assertEquals(e.getKey(), InvalidEditingException.INVALID_MULTIPLICITY_KEY);
        }

    	try {
    		TransactionManager.beginTransaction();
    		attr.setMultiplicity(new int[][] {{10, 5}});
            TransactionManager.endTransaction();
            fail();
    	} catch (InvalidEditingException e) {
    		TransactionManager.abortTransaction();
    		assertEquals(e.getKey(), InvalidEditingException.INVALID_MULTIPLICITY_KEY);
        }
    }