/** * Try creating a stereotype for every modelelement type. * * @param f the factory containing the creation function for all the given metamodel element names * @param names the metamodel element names */ public static void isValidStereoType(Object f, Iterable<String> names) { try { Object ns = Model.getModelManagementFactory().createPackage(); Object clazz = Model.getCoreFactory().buildClass(ns); Object stereo1 = Model.getExtensionMechanismsFactory().buildStereotype(clazz, "test1", ns); for (String name : names) { Method m = findMethod(f.getClass(), Factory.class, "create" + name, new Class[] {}); if (m == null) { TestCase.fail("Failed to find method create" + name); } Object base = m.invoke(f, new Object[] {}); if (Model.getFacade().isAModelElement(base)) { Object stereo2 = Model.getExtensionMechanismsFactory().buildStereotype(base, "test2", ns); TestCase.assertTrue( "Unexpected invalid stereotype", Model.getExtensionMechanismsHelper().isValidStereotype(base, stereo2)); if (!(Model.getFacade().isAClass(base))) { TestCase.assertTrue( "Stereotype with base class of Class" + " incorrectly allowed for this metaclass", !Model.getExtensionMechanismsHelper().isValidStereotype(base, stereo1)); } else { Object inter = Model.getCoreFactory().createInterface(); Object stereo3 = Model.getExtensionMechanismsFactory().buildStereotype(inter, "test3", ns); TestCase.assertTrue( "Unexpected invalid stereotype", !Model.getExtensionMechanismsHelper().isValidStereotype(base, stereo3)); } } } } catch (Exception ex) { ex.printStackTrace(); TestCase.fail("Exception during test metaModelnameCorrect. Message: " + ex.getMessage()); } }
/** 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()); }
/** Test if adding a client to a binary dependency actually increases the client count. */ public void testAddClient() { Object model = Model.getModelManagementFactory().createModel(); Object class1 = Model.getCoreFactory().buildClass(model); Object class2 = Model.getCoreFactory().buildClass(model); Object dep = Model.getCoreFactory().buildDependency(class1, class2); Object class3 = Model.getCoreFactory().buildClass(model); Model.getCoreHelper().addClient(dep, class3); Collection clients = Model.getFacade().getClients(dep); assertEquals(2, Model.getFacade().getClients(dep).size()); Iterator it = clients.iterator(); assertEquals(class1, it.next()); assertEquals(class3, it.next()); }
/** * Delete a model object, frees the reference and then checks that the object is reclaimed. * * <p>This must be called with just one reference to the object or else it will fail. * * @param mo the model object that we try to delete, release and reclaim. * @param name the class name of the uml object */ private static void deleteAndRelease(Object mo, String name) { Class c = mo.getClass(); // Call methods that exists for all objects and that always return // something meaningful TestCase.assertNotNull("toString() corrupt in " + c, mo.toString()); TestCase.assertNotNull( "getUMLClassName() corrupt in " + c, Model.getFacade().getUMLClassName(mo)); TestCase.assertEquals( "getUMLClassName() different from expected in " + c, name, Model.getFacade().getUMLClassName(mo)); Model.getUmlFactory().delete(mo); Model.getPump().flushModelEvents(); TestCase.assertTrue("Could not delete " + c, Model.getUmlFactory().isRemoved(mo)); }
/** * 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()); } }
/** * 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; } } }