/** Test cascading delete to make sure dependent elements disappear. */ public void testDelete() { ExtensionMechanismsFactory emFactory = Model.getExtensionMechanismsFactory(); ExtensionMechanismsHelper emHelper = Model.getExtensionMechanismsHelper(); Object model = Model.getModelManagementFactory().createModel(); Model.getModelManagementFactory().setRootModel(model); Object stereo = emFactory.buildStereotype("mystereo", model); Object td = emFactory.buildTagDefinition("myTD", stereo, null); Object tv = emFactory.buildTaggedValue(td, new String[] {"the tag value"}); Object clazz = Model.getCoreFactory().buildClass("MyClass", model); emHelper.addTaggedValue(clazz, tv); Collection tvs = Model.getFacade().getTaggedValuesCollection(clazz); assertEquals("Wrong number of TaggedValues returned", 1, tvs.size()); assertTrue("TaggedValue not found", tvs.contains(tv)); Collection tds = Model.getModelManagementHelper() .getAllModelElementsOfKind(model, Model.getMetaTypes().getTagDefinition()); assertEquals("TagDefinition not found", 1, tds.size()); // Deleting the stereotype should cascade to the TagDefinition, // then the TaggedValue Model.getUmlFactory().delete(stereo); Model.getPump().flushModelEvents(); tvs = Model.getFacade().getTaggedValuesCollection(clazz); assertEquals("TaggedValue not deleted", 0, tvs.size()); tds = Model.getModelManagementHelper() .getAllModelElementsOfKind(model, Model.getMetaTypes().getTagDefinition()); assertEquals("TagDefinition not deleted", 0, tds.size()); }
/** * Check if for every metamodel element name a create function exists. * * @param factory the modelfactory that should contain the create function * @param names the metamodel class names */ public static void metaModelNameCorrect(Object factory, Iterable<String> names) { Set<String> metaNames = new HashSet<String>(); metaNames.addAll(Arrays.asList(Model.getFacade().getMetatypeNames())); try { for (String name : names) { Method createMethod = findMethod(factory.getClass(), Factory.class, "create" + name, new Class[] {}); TestCase.assertNotNull("Failed to find method create" + name, createMethod); Object element = createMethod.invoke(factory, new Object[] {}); TestCase.assertTrue("Not a UML Element", Model.getFacade().isAUMLElement(element)); String metaName = Model.getMetaTypes().getName(element); TestCase.assertEquals("not a valid metaModelName " + name, metaName, name); TestCase.assertTrue(metaNames.contains(metaName)); TestCase.assertTrue(Model.getFacade().isA(metaName, element)); Method m2 = findMethod(MetaTypes.class, MetaTypes.class, "get" + name, new Class[] {}); Method getMethod; String getMethodName = "get" + name; if ("Class".equals(name)) { getMethodName = "getUMLClass"; } Object metatypes = Model.getMetaTypes(); try { getMethod = MetaTypes.class.getDeclaredMethod(getMethodName, new Class[] {}); } catch (NoSuchMethodException e) { TestCase.fail("Method " + getMethodName + " does not exist in MetaTypes"); return; } TestCase.assertNotNull("Failed to find method get" + getMethodName, getMethod); Object metaElement = createMethod.invoke(factory, new Object[] {}); TestCase.assertTrue(metaElement.getClass().isAssignableFrom(element.getClass())); } } catch (Exception ex) { ex.printStackTrace(); TestCase.fail("Exception during test metaModelnameCorrect. Message: " + ex.getMessage()); } }
/** Test creation. */ public void testCreates() { CheckUMLModelHelper.createAndRelease( Model.getExtensionMechanismsFactory(), getTestableModelElements()); ExtensionMechanismsFactory emFactory = Model.getExtensionMechanismsFactory(); Object model = Model.getModelManagementFactory().createModel(); Object stereo = emFactory.buildStereotype("mystereo1", model); try { emFactory.buildTagDefinition("myTDx", stereo, model); fail("Illegal buildTagDefinition with both sterotype" + " and model didn't throw exception."); } catch (IllegalArgumentException e) { // Expected } emFactory.buildTagDefinition("myTD1", stereo, null); emFactory.buildTagDefinition("myTD2", stereo, null, "Boolean"); Collection tds = Model.getModelManagementHelper() .getAllModelElementsOfKind(model, Model.getMetaTypes().getTagDefinition()); assertEquals("TagDefinition not deleted", 2, tds.size()); }
/** Test subtype check. */ public void testIsSubType() { assertTrue( "Is not a subtype", Model.getCoreHelper() .isSubType(Model.getMetaTypes().getClassifier(), Model.getMetaTypes().getUMLClass())); assertTrue( "Is not a parent type", !Model.getCoreHelper() .isSubType(Model.getMetaTypes().getUMLClass(), Model.getMetaTypes().getClassifier())); assertTrue( "Is not a parent type", !Model.getCoreHelper() .isSubType( Model.getMetaTypes().getUMLClass(), Model.getMetaTypes().getAggregationKind())); }
/** * Create a UML modelelement (i.e. check if a creation function exists). Then deletes it, looses * the reference and then checks that the object is reclaimed. * * @param factory the DataTypesFactory * @param names the UML elements to test * @param arguments the arguments of the UML elements */ public static void createAndRelease(Object factory, Iterable<String> names, Object[] arguments) { Class[] argTypes = new Class[arguments.length]; for (int i = 0; i < arguments.length; i++) { argTypes[i] = arguments[i].getClass(); } // Multiplicity, MultiplicityRange, and all Expression subtypes // don't have 0-argument create methods, so we special case them. Integer[] multArgs = {1, 1}; Class[] multArgTypes = {int.class, int.class}; String[] exprArgs = {"body text", "language text"}; Class[] exprArgTypes = {String.class, String.class}; for (String name : names) { Class[] types; Object[] args; if (name == null) { continue; } else if (name.startsWith("Multiplicity")) { types = multArgTypes; args = multArgs; } else if (name.endsWith("Expression")) { types = exprArgTypes; args = exprArgs; } else { types = argTypes; args = arguments; } String methodName = "create" + name; Method createMethod; // Find the create method in the offical API createMethod = findMethod(factory.getClass(), Factory.class, methodName, types); if (createMethod == null) { TestCase.fail( "Method " + methodName + " does not exist in any interface of factory " + factory.getClass().getName()); return; } Method isAMethod; String isAMethodName = "isA" + name; Object facade = Model.getFacade(); try { // Now get the factory implementation method to be invoked isAMethod = Facade.class.getDeclaredMethod(isAMethodName, new Class[] {Object.class}); } catch (NoSuchMethodException e) { TestCase.fail("Method " + isAMethodName + " does not exist in Facade"); return; } Method getMethod; String getMethodName = "get" + name; if ("Class".equals(name)) { getMethodName = "getUMLClass"; } Object metatypes = Model.getMetaTypes(); try { getMethod = MetaTypes.class.getDeclaredMethod(getMethodName, new Class[] {}); } catch (NoSuchMethodException e) { TestCase.fail("Method " + getMethodName + " does not exist in MetaTypes"); return; } try { // Extra careful now, not to keep any references to the // second argument. try { Object element = invoke(createMethod, factory, args); TestCase.assertTrue( "Facade method " + isAMethodName + " returned false", (Boolean) invoke(isAMethod, facade, new Object[] {element})); TestCase.assertTrue(Model.getFacade().isA(name, element)); Object metaElement = invoke(getMethod, metatypes, new Object[0]); TestCase.assertTrue(((Class) metaElement).isAssignableFrom(element.getClass())); deleteAndRelease(createMethod.invoke(factory, args), name); } catch (ClassCastException e) { // Here it is another object sent to the test. deleteAndRelease(createMethod.invoke(factory, args)); } catch (IllegalArgumentException e) { // Here it is another object sent to the test. deleteAndRelease(createMethod.invoke(factory, args)); } } catch (IllegalAccessException e) { TestCase.fail("Method create" + name + " in " + factory + " cannot be called"); return; } catch (InvocationTargetException e) { TestCase.fail("Method create" + name + " in " + factory + " throws an exception."); return; } } }
/* * @see junit.framework.TestCase#setUp() */ protected void setUp() throws Exception { super.setUp(); setTruth(Model.getMetaTypes().getModelElement(), true); }
/** * Constructor. * * @param arg0 test name */ public TestUmlModelElement(String arg0) { super(arg0); setEntity(Model.getMetaTypes().getModelElement()); validateTestClassIsGeneric(this); }