/** 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());
}
/**
* 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 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());
}
/** 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 the getFirstSharedNamespace method for correctness and, optionally, performance. */
public void testGetFirstSharedNamespace() {
Object model = Model.getModelManagementFactory().createModel();
CoreFactory cf = Model.getCoreFactory();
// Build namespace hierarchy like this:
// g a
// /\
// b c
// /\
// d e f
Object a = cf.buildClass("a", model);
Object b = cf.buildClass("b", a);
Object c = cf.buildClass("c", a);
Object d = cf.buildClass("d", c);
Object e = cf.buildClass("e", c);
Object f = cf.buildClass("f", c);
Object g = cf.buildClass();
CoreHelper ch = Model.getCoreHelper();
assertEquals("Got wrong namespace for first shared", a, ch.getFirstSharedNamespace(b, e));
assertEquals("Got wrong namespace for first shared", c, ch.getFirstSharedNamespace(d, e));
assertEquals("Got wrong namespace for first shared", a, ch.getFirstSharedNamespace(a, e));
assertEquals("Got wrong namespace for first shared", a, ch.getFirstSharedNamespace(a, c));
assertEquals("Got wrong namespace for first shared", a, ch.getFirstSharedNamespace(b, c));
assertNull(
"getFirstSharedNamespace didn't return null" + " when none shared",
ch.getFirstSharedNamespace(g, a));
// Try changing namespace of element and make sure results track
assertEquals("Got wrong namespace for first shared", c, ch.getFirstSharedNamespace(d, f));
ch.setNamespace(f, b);
ch.setNamespace(g, f);
assertEquals("Got wrong namespace after setNamespace", a, ch.getFirstSharedNamespace(d, f));
assertEquals("Got wrong namespace after setNamespace", a, ch.getFirstSharedNamespace(g, e));
if (PERFORMANCE_TEST) {
List children = new ArrayList();
Object root = cf.buildClass();
children.add(root);
createChildren(children, root, 0, NAMESPACE_LEVELS, CHILDREN_PER_NAMESPACE);
// Tree is created depth first, so this should be at the bottom
Object base = children.get(NAMESPACE_LEVELS);
long startTime = System.currentTimeMillis();
int i;
for (i = 0; i < children.size(); i++) {
Object o = ch.getFirstSharedNamespace(base, children.get(i));
if (i % 100 == 0) {
// Check periodically to see if we've exceeded time limit
if ((System.currentTimeMillis() - startTime) > TIME_LIMIT) {
break;
}
}
}
long endTime = System.currentTimeMillis();
System.out.println(
"Iterations: " + i + ", time: " + (endTime - startTime) / 1.0e3 + " seconds.");
System.out.println(
"Average time for getFirstSharedNameSpace = "
+ (endTime - startTime) * 1.0 / i
+ " millisecs searching in "
+ children.size()
+ " total elements.");
}
}