/** Test getting children. */
public void testGetChildren() {
CoreFactory coreFactory = Model.getCoreFactory();
// Create a generalizable element with an element without children.
Object ge = coreFactory.createClass();
assertTrue(Model.getCoreHelper().getChildren(ge).size() == 0);
// Add one child.
Object g1 = coreFactory.createGeneralization();
Model.getCoreHelper().setParent(g1, ge);
Model.getCoreHelper().setChild(g1, coreFactory.createClass());
assertTrue(Model.getCoreHelper().getChildren(ge).size() == 1);
// Add another child.
Object g2 = coreFactory.createGeneralization();
Model.getCoreHelper().setParent(g2, ge);
Object ge2 = coreFactory.createClass();
Model.getCoreHelper().setChild(g2, ge2);
assertTrue(Model.getCoreHelper().getChildren(ge).size() == 2);
// Add grandchild.
Object g3 = coreFactory.createGeneralization();
Model.getCoreHelper().setParent(g3, ge2);
Model.getCoreHelper().setChild(g3, coreFactory.createClass());
assertTrue(Model.getCoreHelper().getChildren(ge).size() == 3);
}
/** 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()));
}
/** 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());
}
/*
* Populate our namespace hierarchy to the requested depth. Total number
* of created elements is children^maxLevel, so be careful not to increase
* parameters too much.
*/
private List createChildren(
List children, Object parent, int currentLevel, int maxLevel, int numChildren) {
currentLevel++;
if (currentLevel > maxLevel) {
return children;
}
Object child;
for (int i = 0; i < numChildren; i++) {
child = Model.getCoreFactory().buildClass("l" + currentLevel + "n" + i);
children.add(child);
Model.getCoreHelper().setNamespace(child, parent);
createChildren(children, child, currentLevel, maxLevel, numChildren);
}
return children;
}
/** 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.");
}
}
