/**
* 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;
}
}
}
