/*******************************************************************************
* Copyright (c) 2010, 2011 SAP AG and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* SAP AG - initial API and implementation
*******************************************************************************/
package org.eclipse.ocl.examples.eventmanager.tests;
import junit.framework.TestCase;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.DynamicEObjectImpl;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.ocl.examples.eventmanager.EventFilter;
import org.eclipse.ocl.examples.eventmanager.EventManager;
import org.eclipse.ocl.examples.eventmanager.EventManagerFactory;
import org.eclipse.ocl.examples.eventmanager.tests.EventManagerTest.Application;
public class LogicalFilterTest extends TestCase {
private EventManager fixture;
private Application app;
private EClass eClass1;
private EventFilter featureFilterRef;
private DynamicEObjectImpl eObjectCls1;
private EClass eClass2;
private DynamicEObjectImpl eObjectCls2;
private EClass eClass3;
private DynamicEObjectImpl eObjectCls3;
private EClass eClass4;
private DynamicEObjectImpl eObjectCls4;
private EReference ref;
private EventFilter typeFilterAdd;
private EventFilter classFilterCls1;
private EventFilter oldValueFilterCls2;
private EventFilter newValueFilterCls2;
private EventFilter newValueFilterCls3;
private EventFilter newValueFilterWithSubclassesCls3;
private EventFilter newValueFilterWithSubclassesCls4;
public void setUp() throws Exception {
fixture = EventManagerFactory.eINSTANCE.createEventManager();
app = new Application();
eClass1 = EcoreFactory.eINSTANCE.createEClass();
eClass1.setName("c1");
eObjectCls1 = new DynamicEObjectImpl(eClass1);
eClass2 = EcoreFactory.eINSTANCE.createEClass();
eClass2.setName("c2");
eObjectCls2 = new DynamicEObjectImpl(eClass2);
eClass3 = EcoreFactory.eINSTANCE.createEClass();
eClass3.setName("c3");
eObjectCls3 = new DynamicEObjectImpl(eClass3);
eClass4 = EcoreFactory.eINSTANCE.createEClass();
eClass4.setName("c4");
eClass4.getESuperTypes().add(eClass3); // c4 extends c3
eObjectCls4 = new DynamicEObjectImpl(eClass4);
ref = EcoreFactory.eINSTANCE.createEReference();
typeFilterAdd = EventManagerFactory.eINSTANCE.createEventTypeFilter(Notification.ADD);
classFilterCls1 = EventManagerFactory.eINSTANCE.createClassFilter(eClass1);
oldValueFilterCls2 = EventManagerFactory.eINSTANCE.createOldValueClassFilter(eClass2);
newValueFilterCls2 = EventManagerFactory.eINSTANCE.createNewValueClassFilter(eClass2);
newValueFilterCls3 = EventManagerFactory.eINSTANCE.createNewValueClassFilter(eClass3);
newValueFilterWithSubclassesCls3 = EventManagerFactory.eINSTANCE.createNewValueClassFilterIncludingSubclasses(eClass3);
newValueFilterWithSubclassesCls4 = EventManagerFactory.eINSTANCE.createNewValueClassFilterIncludingSubclasses(eClass4);
featureFilterRef = EventManagerFactory.eINSTANCE.createStructuralFeatureFilter(ref);
}
public void tearDown() throws Exception {
fixture.unsubscribe(app);
fixture=null;
app=null;
}
public void testMatchingAndWithSameFilterTypeOnSameElementOfMultiNewValue() {
EList<EObject> newValue = new BasicEList<EObject>();
newValue.add(eObjectCls3);
newValue.add(eObjectCls4);
Notification n = new ENotificationImpl((InternalEObject) eObjectCls1,
Notification.ADD_MANY, ref, null, newValue);
// require an element from newValue to match both eClass3 and eClass4
// which is possible because eClass4 extends eClass3
EventFilter f = EventManagerFactory.eINSTANCE.createAndFilterFor(
newValueFilterWithSubclassesCls3, newValueFilterWithSubclassesCls4);
assertTrue(f.matchesFor(n)); // should match because eObjectCls4 matches both filters
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertTrue("Did not get notified", app.isNotified());
}
public void testMatchingAndWithSameFilterTypeOnDifferentElementsOfMultiNewValue() {
EList<EObject> newValue = new BasicEList<EObject>();
newValue.add(eObjectCls2);
newValue.add(eObjectCls3);
Notification n = new ENotificationImpl((InternalEObject) eObjectCls1,
Notification.ADD_MANY, ref, null, newValue);
// require an element from newValue to match both eClass3 and eClass4
// which is not possible for a single element because eClass2 and eClass3 are
// not in any inheritance relationship
EventFilter f = EventManagerFactory.eINSTANCE.createAndFilterFor(
newValueFilterCls2, newValueFilterCls3);
// neither eObjectCls2 nor eObjectCls3 both fulfill filter for eClass2+eClass3,
// but each individual NewValueClassFilter matches one of the two objects, and
// so the AndFilter matches, too.
assertTrue(f.matchesFor(n));
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertTrue("Did not get notified", app.isNotified());
}
public void testSimpleAndFilter1Stage(){
Notification n = new ENotificationImpl((InternalEObject) eObjectCls1, Notification.ADD, ref, eObjectCls2, eObjectCls3);
EventFilter f = EventManagerFactory.eINSTANCE.createAndFilterFor(typeFilterAdd,classFilterCls1,oldValueFilterCls2,newValueFilterCls3,featureFilterRef);
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertTrue("Did not get notified", app.isNotified());
}
public void testSimpleAndFilter3Stage(){
Notification n = new ENotificationImpl((InternalEObject) eObjectCls1, Notification.ADD, ref, eObjectCls2, eObjectCls3);
EventFilter f7 = EventManagerFactory.eINSTANCE.createAndFilterFor(
EventManagerFactory.eINSTANCE.createAndFilterFor(
typeFilterAdd,
classFilterCls1),
EventManagerFactory.eINSTANCE.createAndFilterFor(
oldValueFilterCls2,
EventManagerFactory.eINSTANCE.createAndFilterFor(
newValueFilterCls3,
featureFilterRef)));
fixture.subscribe(f7, app);
fixture.handleEMFEvent(n);
assertTrue("Did not get notified", app.isNotified());
}
public void testSimpleOrFilter1Stage1(){
Notification n = new ENotificationImpl((InternalEObject) eObjectCls1, 0, null, null, null);
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(typeFilterAdd,classFilterCls1,oldValueFilterCls2,newValueFilterCls3,featureFilterRef);
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertTrue("Did not get notified", app.isNotified());
}
public void testSimpleOrFilter1Stage2(){
Notification n = new ENotificationImpl(null, Notification.ADD, null, null, null);
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(typeFilterAdd,classFilterCls1,oldValueFilterCls2,newValueFilterCls3,featureFilterRef);
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertTrue("Did not get notified", app.isNotified());
}
public void testSimpleOrFilter1Stage3(){
Notification n = new ENotificationImpl(null, 0, null, eObjectCls2, null);
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(typeFilterAdd,classFilterCls1,oldValueFilterCls2,newValueFilterCls3,featureFilterRef);
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertTrue("Did not get notified", app.isNotified());
}
public void testSimpleOrFilter1Stage4(){
Notification n = new ENotificationImpl(null, 0, null, null, eObjectCls3);
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(typeFilterAdd,classFilterCls1,oldValueFilterCls2,newValueFilterCls3,featureFilterRef);
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertTrue("Did not get notified", app.isNotified());
}
public void testSimpleOrFilter1Stage5(){
Notification n = new ENotificationImpl(null, 0, null, null, null);
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(typeFilterAdd,classFilterCls1,oldValueFilterCls2,newValueFilterCls3,featureFilterRef);
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertFalse("Get notified", app.isNotified());
}
public void testSimpleOrFilter2Stage1(){
Notification n = new ENotificationImpl(null, 0, null, null, eObjectCls3);
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
typeFilterAdd,
classFilterCls1),
EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
oldValueFilterCls2,
newValueFilterCls3),
featureFilterRef));
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertTrue("Did not get notified", app.isNotified());
}
public void testSimpleOrFilter2Stage2(){
Notification n = new ENotificationImpl(null, 0, null, null, null);
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
typeFilterAdd,
classFilterCls1),
EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
oldValueFilterCls2,
newValueFilterCls3),
featureFilterRef));
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertFalse("Get notified", app.isNotified());
}
public void testSimpleOrFilter2StageAndNot1(){
Notification n = new ENotificationImpl(null, 0, null, null, eObjectCls3);
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
typeFilterAdd,
classFilterCls1),
EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
oldValueFilterCls2,
EventManagerFactory.eINSTANCE.createNotFilter(newValueFilterCls3)),
featureFilterRef));
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertFalse("Get notified", app.isNotified());
}
public void testSimpleOrFilter2StageAndNot2(){
Notification n = new ENotificationImpl(null, 0, null, null, eObjectCls3);
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
typeFilterAdd,
classFilterCls1),
EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
oldValueFilterCls2,
EventManagerFactory.eINSTANCE.createNotFilter(newValueFilterCls3)),
featureFilterRef));
f = EventManagerFactory.eINSTANCE.createNotFilter(f);
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertTrue("Get not notified", app.isNotified());
}
public void testSimpleOrFilter2StageDoubleNot(){
Notification n = new ENotificationImpl(null, 0, null, null, eObjectCls3);
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
typeFilterAdd,
classFilterCls1),
EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
oldValueFilterCls2,
EventManagerFactory.eINSTANCE.createNotFilter(newValueFilterCls3)),
featureFilterRef));
f = EventManagerFactory.eINSTANCE.createNotFilter(f);
f = EventManagerFactory.eINSTANCE.createNotFilter(f);
fixture.subscribe(f, app);
fixture.handleEMFEvent(n);
assertFalse("Get notified", app.isNotified());
}
/**
* And for 2 identical expressions should get converted to one
*/
public void testDeMorgan1(){
EventFilter f = EventManagerFactory.eINSTANCE.createAndFilterFor(
EventManagerFactory.eINSTANCE.createNotFilter(
EventManagerFactory.eINSTANCE.createAndFilterFor(
newValueFilterCls3,
oldValueFilterCls2)),
EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createNotFilter(
newValueFilterCls3
),
EventManagerFactory.eINSTANCE.createNotFilter(
oldValueFilterCls2
))
);
f = EventManagerFactory.eINSTANCE.createNotFilter(f);
fixture.subscribe(f, app);
Notification n = new ENotificationImpl(null, 0, null, null, eObjectCls3);
fixture.handleEMFEvent(n);
Notification n3 = new ENotificationImpl(null, 0, null, eObjectCls2, null);
fixture.handleEMFEvent(n3);
assertFalse("Get notified",app.isNotified());
Notification n4 = new ENotificationImpl(null, 0, null, eObjectCls2, eObjectCls3);
fixture.handleEMFEvent(n4);
assertTrue("Did not get notified",app.isNotified());
}
/**
* And for 2 identical expressions should get converted to one
*/
public void testDeMorgan2(){
EventFilter f = EventManagerFactory.eINSTANCE.createAndFilterFor(
EventManagerFactory.eINSTANCE.createNotFilter(
EventManagerFactory.eINSTANCE.createOrFilterFor(
newValueFilterCls3,
oldValueFilterCls2)),
EventManagerFactory.eINSTANCE.createAndFilterFor(
EventManagerFactory.eINSTANCE.createNotFilter(
newValueFilterCls3
),
EventManagerFactory.eINSTANCE.createNotFilter(
oldValueFilterCls2
))
);
fixture.subscribe(f, app);
Notification n = new ENotificationImpl(null, 0, null, null, eObjectCls3);
fixture.handleEMFEvent(n);
Notification n3 = new ENotificationImpl(null, 0, null, eObjectCls2, null);
fixture.handleEMFEvent(n3);
Notification n4 = new ENotificationImpl(null, 0, null, eObjectCls2, eObjectCls3);
fixture.handleEMFEvent(n4);
assertFalse("Get notified",app.isNotified());
Notification n5 = new ENotificationImpl(null, 0, null, null, null);
fixture.handleEMFEvent(n5);
assertTrue("Did not get notified",app.isNotified());
}
/**
* Tautology
*/
public void testDeMorganTautology(){
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
newValueFilterCls3,
oldValueFilterCls2),
EventManagerFactory.eINSTANCE.createAndFilterFor(
EventManagerFactory.eINSTANCE.createNotFilter(
newValueFilterCls3
),
EventManagerFactory.eINSTANCE.createNotFilter(
oldValueFilterCls2
))
);
fixture.subscribe(f, app);
Notification n = new ENotificationImpl(null, 0, null, null, eObjectCls3);
fixture.handleEMFEvent(n);
assertTrue("Did not get notified",app.isNotified());
app.reset();
Notification n3 = new ENotificationImpl(null, 0, null, eObjectCls2, null);
fixture.handleEMFEvent(n3);
assertTrue("Did not get notified",app.isNotified());
app.reset();
Notification n4 = new ENotificationImpl(null, 0, null, eObjectCls2, eObjectCls3);
fixture.handleEMFEvent(n4);
assertTrue("Did not get notified",app.isNotified());
app.reset();
Notification n5 = new ENotificationImpl(null, 0, null, null, null);
fixture.handleEMFEvent(n5);
assertTrue("Did not get notified",app.isNotified());
}
/**
* Check that negated filters has the same influence as normal
*/
public void testPriorityOfNegatedFilters(){
EventFilter f = EventManagerFactory.eINSTANCE.createAndFilterFor(
classFilterCls1,
EventManagerFactory.eINSTANCE.createNotFilter(newValueFilterCls3));
fixture.subscribe(f, app);
Notification n = new ENotificationImpl(null, 0, null, null, eObjectCls3);
fixture.handleEMFEvent(n);
assertFalse("Erroneously got notified",app.isNotified());
app.reset();
Notification n2 = new ENotificationImpl(eObjectCls1, 0, null, null, eObjectCls2);
fixture.handleEMFEvent(n2);
assertTrue("Did not get notified",app.isNotified());
app.reset();
Notification n3 = new ENotificationImpl(eObjectCls1, 0, null, null, eObjectCls3);
fixture.handleEMFEvent(n3);
assertFalse("Erroneously got notified",app.isNotified());
app.reset();
Notification n4 = new ENotificationImpl(null, 0, null, null, null);
fixture.handleEMFEvent(n4);
assertFalse("Erroneously got notified",app.isNotified());
}
/**
* Check that negated filters has the same influence as normal
*/
public void testPriorityOfNegatedFiltersReversed(){
EventFilter f = EventManagerFactory.eINSTANCE.createAndFilterFor(
EventManagerFactory.eINSTANCE.createNotFilter(classFilterCls1),
newValueFilterCls3);
fixture.subscribe(f, app);
Notification n = new ENotificationImpl(null, 0, null, null, eObjectCls3);
fixture.handleEMFEvent(n);
assertTrue("Did not get notified",app.isNotified());
app.reset();
Notification n2 = new ENotificationImpl(eObjectCls1, 0, null, null, eObjectCls2);
fixture.handleEMFEvent(n2);
assertFalse("Erroneously got notified",app.isNotified());
app.reset();
Notification n3 = new ENotificationImpl(eObjectCls1, 0, null, null, eObjectCls3);
fixture.handleEMFEvent(n3);
assertFalse("Erroneously got notified",app.isNotified());
app.reset();
Notification n4 = new ENotificationImpl(null, 0, null, null, null);
fixture.handleEMFEvent(n4);
assertFalse("Erroneously got notified",app.isNotified());
}
/**
* Tests whether two filters of the same type in an And get handled correctly
*/
public void testAndForSameFilterType(){
EventFilter f = EventManagerFactory.eINSTANCE.createAndFilterFor(
EventManagerFactory.eINSTANCE.createClassFilter(eClass1),
EventManagerFactory.eINSTANCE.createClassFilter(eClass2));
fixture.subscribe(f, app);
Notification n = new ENotificationImpl(eObjectCls1, 0, null, null, null);
fixture.handleEMFEvent(n);
assertFalse("Erroneously got notified",app.isNotified());
app.reset();
Notification n3 = new ENotificationImpl(eObjectCls2, 0, null, null, null);
fixture.handleEMFEvent(n3);
assertFalse("Erroneously got notified",app.isNotified());
app.reset();
Notification n6 = new ENotificationImpl(null, 0, null, null, null);
fixture.handleEMFEvent(n6);
assertFalse("Erroneously got notified",app.isNotified());
}
/**
* Tests the behavior for a simple contradiction with the same filter once not and once negated
*/
public void testSimpleContradiction(){
EventFilter f = EventManagerFactory.eINSTANCE.createAndFilterFor(
newValueFilterCls3,
EventManagerFactory.eINSTANCE.createNotFilter(newValueFilterCls3));
fixture.subscribe(f, app);
Notification n3 = new ENotificationImpl(null, 0, null, null, eObjectCls2);
fixture.handleEMFEvent(n3);
assertFalse("Erroneously got notified",app.isNotified());
app.reset();
Notification n6 = new ENotificationImpl(null, 0, null, null, eObjectCls3);
fixture.handleEMFEvent(n6);
assertFalse("Erroneously got notified",app.isNotified());
}
/**
* Contradiction
*/
public void testDeMorganContradiction(){
EventFilter f = EventManagerFactory.eINSTANCE.createAndFilterFor(
EventManagerFactory.eINSTANCE.createOrFilterFor(
newValueFilterCls3,
oldValueFilterCls2),
EventManagerFactory.eINSTANCE.createAndFilterFor(
EventManagerFactory.eINSTANCE.createNotFilter(newValueFilterCls3),
EventManagerFactory.eINSTANCE.createNotFilter(oldValueFilterCls2)));
fixture.subscribe(f, app);
Notification n3 = new ENotificationImpl(null, 0, null, eObjectCls2, null);
fixture.handleEMFEvent(n3);
assertFalse("Erroneously got notified",app.isNotified());
app.reset();
Notification n4 = new ENotificationImpl(null, 0, null, eObjectCls2, eObjectCls3);
fixture.handleEMFEvent(n4);
assertFalse("Erroneously got notified",app.isNotified());
app.reset();
Notification n5 = new ENotificationImpl(null, 0, null, eObjectCls3, eObjectCls2);
fixture.handleEMFEvent(n5);
assertFalse("Erroneously got notified",app.isNotified());
app.reset();
Notification n6 = new ENotificationImpl(null, 0, null, null, null);
fixture.handleEMFEvent(n6);
assertFalse("Erroneously got notified",app.isNotified());
}
public void testDisjunctiveConversion(){
EventFilter f = EventManagerFactory.eINSTANCE.createOrFilterFor(
EventManagerFactory.eINSTANCE.createNotFilter(
EventManagerFactory.eINSTANCE.createAndFilterFor(
newValueFilterCls3,
oldValueFilterCls2)),
newValueFilterCls3
);
fixture.subscribe(f, app);
boolean notNotfied = false;
Notification n = new ENotificationImpl(null, 0, null, null, eObjectCls3);
fixture.handleEMFEvent(n);
notNotfied = notNotfied || !app.isNotified();
Notification n3 = new ENotificationImpl(null, 0, null, eObjectCls2, null);
fixture.handleEMFEvent(n3);
notNotfied = notNotfied || !app.isNotified();
Notification n4 = new ENotificationImpl(null, 0, null, null, null);
fixture.handleEMFEvent(n4);
notNotfied = notNotfied || !app.isNotified();
assertFalse("Did not get notified", notNotfied);
}
}