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