| /******************************************************************************* |
| * Copyright (c) 2009, 2018 SAP AG and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v20.html |
| * |
| * Contributors: |
| * SAP AG - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.ocl.examples.impactanalyzer.tests.instanceScope; |
| |
| import java.util.Collection; |
| |
| import modelmanagement.ModelmanagementFactory; |
| import modelmanagement.ModelmanagementPackage; |
| |
| import org.eclipse.emf.common.notify.Adapter; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.impl.AdapterImpl; |
| import org.eclipse.emf.ecore.EAttribute; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl; |
| import org.eclipse.emf.ecore.util.ECrossReferenceAdapter; |
| import org.eclipse.ocl.common.OCLConstants; |
| import org.eclipse.ocl.common.internal.options.CommonOptions; |
| import org.eclipse.ocl.ecore.OCL; |
| import org.eclipse.ocl.ecore.OCLExpression; |
| import org.eclipse.ocl.examples.impactanalyzer.ImpactAnalyzer; |
| import org.eclipse.ocl.examples.impactanalyzer.ImpactAnalyzerFactory; |
| import org.eclipse.ocl.examples.impactanalyzer.benchmark.preparation.notifications.NotificationHelper; |
| import org.eclipse.ocl.examples.impactanalyzer.configuration.OptimizationActivation; |
| import org.eclipse.ocl.examples.impactanalyzer.testutils.BaseDepartmentTestWithOCL; |
| import org.eclipse.ocl.examples.impactanalyzer.util.OCLFactory; |
| import org.junit.Test; |
| |
| import behavioral.actions.ActionsFactory; |
| import data.classes.Association; |
| import data.classes.AssociationEnd; |
| import data.classes.ClassTypeDefinition; |
| import data.classes.ClassesFactory; |
| import data.classes.ClassesPackage; |
| import data.classes.MethodSignature; |
| import data.classes.Parameter; |
| import data.classes.SapClass; |
| import data.classes.SignatureImplementation; |
| import data.classes.TypeAdapter; |
| import dataaccess.expressions.ExpressionsFactory; |
| import dataaccess.expressions.ExpressionsPackage; |
| import dataaccess.expressions.MethodCallExpression; |
| import dataaccess.expressions.ObjectCreationExpression; |
| import dataaccess.expressions.VariableExpression; |
| import dataaccess.expressions.literals.LiteralsFactory; |
| import dataaccess.expressions.literals.LiteralsPackage; |
| import dataaccess.expressions.literals.ObjectLiteral; |
| import dataaccess.expressions.literals.StringLiteral; |
| |
| public class OclIaTest extends BaseDepartmentTestWithOCL { |
| |
| private static final String testAnalysisOfRecursiveOperationWithSelf = "context dataaccess::expressions::MethodCallExpression \n" |
| + "inv testAnalysisOfRecursiveOperationWithSelf: \n" |
| + "self.object.getType().getInnermost().oclAsType(data::classes::ClassTypeDefinition).clazz.allSignatures() \n" |
| + "->select(s | s.name = 'testMethod')"; |
| |
| private static final String testAllInstancesSelectClassName = "context data::classes::ClassTypeDefinition \n" |
| + "inv testAllInstancesSelectClassName:\n" + "data::classes::SapClass.allInstances()->select(c | c.name = 'Bob')"; |
| |
| private static final String testVerySimpleTracerBasedInstanceScopeAnalysisWithNewClassScopeAnalysis = "context data::classes::SapClass \n" |
| + "inv testVerySimpleTracerBasedInstanceScopeAnalysisWithNewClassScopeAnalysis: \n" |
| + "self.oclAsType(data::classes::SapClass).name"; |
| |
| private static final String testLongRunningNavigationPathExpression = "context data::classes::AssociationEnd inv LongRunningNavigationPath: \n " |
| + "'.'.concat(self.oclAsType(data::classes::AssociationEnd).name)"; |
| |
| private static final String testLowerMultiplicityPropagationForMethodCall = "context data::classes::ClassTypeDefinition \n" |
| + "inv testLowerMultiplicityPropagationForMethodCallOnParameterUsage: \n" |
| + "self.ownerTypedElement.oclAsType(dataaccess::expressions::MethodCallExpression).methodSignature.output.lowerMultiplicity * \n" |
| + "self.ownerTypedElement.oclAsType(dataaccess::expressions::MethodCallExpression).object.getType().lowerMultiplicity"; |
| |
| private static final String testInstanceScopeAnalysisForRecursiveOperation = "context data::classes::SapClass \n" |
| + "inv testInstanceScopeAnalysisForRecursiveOperation: \n" + "self.adapters->forAll(a | self.conformsTo(a.to))"; |
| |
| private static final String testVerySimpleInstanceScopeAnalysisWithTupleUsingSelf = "context data::classes::SapClass \n" |
| + "inv testVerySimpleInstanceScopeAnalysisWithTupleUsingSelf: \n" + "Tuple{cls=self}.cls.name"; |
| |
| private static final String testVerySimpleInstanceScopeAnalysisWithTuple = "context data::classes::SapClass \n" |
| + "inv testVerySimpleInstanceScopeAnalysisWithTuple: \n" + "Tuple{name=self.name}.name"; |
| |
| private static final String testForIA2 = "context dataaccess::expressions::literals::ObjectLiteral \n" + "inv testForIA2: \n" |
| + "self.oclAsType(dataaccess::expressions::literals::ObjectLiteral).valueClass.getAssociationEnds().otherEnd()" |
| + "->select(ae|ae.name='Assoc_to_Bob_changed')"; |
| |
| private EPackage cp; |
| private ResourceSetImpl rs; |
| |
| @Override |
| public void setUp() { |
| CommonOptions.DEFAULT_DELEGATION_MODE.setDefaultValue(OCLConstants.OCL_DELEGATE_URI_LPG); |
| this.cp = ClassesPackage.eINSTANCE; |
| this.rs = new ResourceSetImpl(); |
| this.rs.eAdapters().add(new ECrossReferenceAdapter()); |
| this.rs.getResources().add(this.cp.eResource()); |
| } |
| |
| @Override |
| public void tearDown() { |
| this.rs = null; |
| this.cp = null; |
| } |
| |
| @Test |
| public void testSelectByType() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testSelectByType:\n" + |
| "self.ownedSignatures.implementation->selectByType(data::classes::LinkSetting).implements_.output"+ |
| ".oclAsType(data::classes::ClassTypeDefinition).clazz.name", |
| this.cp).iterator().next().getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c1 = ClassesFactory.eINSTANCE.createSapClass(); |
| c1.setName("c1"); |
| MethodSignature ms1 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms1.setName("ms1"); |
| c1.getOwnedSignatures().add(ms1); |
| SapClass c2 = ClassesFactory.eINSTANCE.createSapClass(); |
| c2.setName("c2"); |
| MethodSignature ms2 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms2.setName("ms2"); |
| c2.getOwnedSignatures().add(ms2); |
| SignatureImplementation ms1Impl = ActionsFactory.eINSTANCE.createBlock(); |
| ms1.setImplementation(ms1Impl); |
| SignatureImplementation ms2Impl = ClassesFactory.eINSTANCE.createLinkSetting(); |
| ms2.setImplementation(ms2Impl); |
| SapClass output = ClassesFactory.eINSTANCE.createSapClass(); |
| output.setName("Output"); |
| ClassTypeDefinition outputCtdForMs1 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ClassTypeDefinition outputCtdForMs2 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| outputCtdForMs1.setClazz(output); |
| outputCtdForMs2.setClazz(output); |
| ms1.setOutput(outputCtdForMs1); |
| ms2.setOutput(outputCtdForMs2); |
| |
| Collection<?> resultOnC1 = (Collection<?>) OCL.newInstance().evaluate(c1, expression); |
| assertTrue(resultOnC1.isEmpty()); |
| Collection<?> resultOnC2 = (Collection<?>) OCL.newInstance().evaluate(c2, expression); |
| assertEquals(1, resultOnC2.size()); |
| assertTrue(resultOnC2.contains("Output")); |
| |
| final Notification[] noti = new Notification[1]; |
| Adapter adapter = new AdapterImpl() { |
| @Override |
| public void notifyChanged(Notification msg) { |
| noti[0] = msg; |
| } |
| }; |
| output.eAdapters().add(adapter); |
| |
| output.setName("NewOutput"); |
| Collection<?> newResultOnC1 = (Collection<?>) OCL.newInstance().evaluate(c1, expression); |
| assertTrue(newResultOnC1.isEmpty()); |
| Collection<?> newResultOnC2 = (Collection<?>) OCL.newInstance().evaluate(c2, expression); |
| assertEquals(1, newResultOnC2.size()); |
| assertTrue(newResultOnC2.contains("NewOutput")); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti[0]); |
| assertEquals(1, impact.size()); // expecting only c2 to be impacted because c1's ms1 implementation has the wrong type |
| assertFalse(impact.contains(c1)); |
| assertTrue(impact.contains(c2)); |
| } |
| |
| @Test |
| public void testSelectByTypeForSubclass() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testSelectByTypeForSubclass:\n" + |
| "self.ownedSignatures.implementation->selectByType(data::classes::SignatureImplementation).implements_.output"+ |
| ".oclAsType(data::classes::ClassTypeDefinition).clazz.name", |
| this.cp).iterator().next().getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c1 = ClassesFactory.eINSTANCE.createSapClass(); |
| c1.setName("c1"); |
| MethodSignature ms1 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms1.setName("ms1"); |
| c1.getOwnedSignatures().add(ms1); |
| SapClass c2 = ClassesFactory.eINSTANCE.createSapClass(); |
| c2.setName("c2"); |
| MethodSignature ms2 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms2.setName("ms2"); |
| c2.getOwnedSignatures().add(ms2); |
| SignatureImplementation ms1Impl = ActionsFactory.eINSTANCE.createBlock(); |
| ms1.setImplementation(ms1Impl); |
| SignatureImplementation ms2Impl = ClassesFactory.eINSTANCE.createLinkSetting(); |
| ms2.setImplementation(ms2Impl); |
| SapClass output = ClassesFactory.eINSTANCE.createSapClass(); |
| output.setName("Output"); |
| ClassTypeDefinition outputCtdForMs1 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ClassTypeDefinition outputCtdForMs2 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| outputCtdForMs1.setClazz(output); |
| outputCtdForMs2.setClazz(output); |
| ms1.setOutput(outputCtdForMs1); |
| ms2.setOutput(outputCtdForMs2); |
| |
| Collection<?> resultOnC1 = (Collection<?>) OCL.newInstance().evaluate(c1, expression); |
| assertTrue(resultOnC1.isEmpty()); |
| Collection<?> resultOnC2 = (Collection<?>) OCL.newInstance().evaluate(c2, expression); |
| assertTrue(resultOnC2.isEmpty()); |
| |
| final Notification[] noti = new Notification[1]; |
| Adapter adapter = new AdapterImpl() { |
| @Override |
| public void notifyChanged(Notification msg) { |
| noti[0] = msg; |
| } |
| }; |
| output.eAdapters().add(adapter); |
| |
| output.setName("NewOutput"); |
| Collection<?> newResultOnC1 = (Collection<?>) OCL.newInstance().evaluate(c1, expression); |
| assertTrue(newResultOnC1.isEmpty()); |
| Collection<?> newResultOnC2 = (Collection<?>) OCL.newInstance().evaluate(c2, expression); |
| assertTrue(newResultOnC2.isEmpty()); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti[0]); |
| assertTrue(impact.isEmpty()); // expecting neither c1 nor c2 to be in |
| // the result because neither Block nor |
| // LinkSetting has exactly type |
| // SignatureImplementation |
| } |
| |
| @Test |
| public void testSelectByKind() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testSelectByKind:\n" + |
| "self.ownedSignatures.implementation->selectByKind(data::classes::LinkSetting).implements_.output"+ |
| ".oclAsType(data::classes::ClassTypeDefinition).clazz.name", |
| this.cp).iterator().next().getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c1 = ClassesFactory.eINSTANCE.createSapClass(); |
| c1.setName("c1"); |
| MethodSignature ms1 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms1.setName("ms1"); |
| c1.getOwnedSignatures().add(ms1); |
| SapClass c2 = ClassesFactory.eINSTANCE.createSapClass(); |
| c2.setName("c2"); |
| MethodSignature ms2 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms2.setName("ms2"); |
| c2.getOwnedSignatures().add(ms2); |
| SignatureImplementation ms1Impl = ActionsFactory.eINSTANCE.createBlock(); |
| ms1.setImplementation(ms1Impl); |
| SignatureImplementation ms2Impl = ClassesFactory.eINSTANCE.createLinkSetting(); |
| ms2.setImplementation(ms2Impl); |
| SapClass output = ClassesFactory.eINSTANCE.createSapClass(); |
| output.setName("Output"); |
| ClassTypeDefinition outputCtdForMs1 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ClassTypeDefinition outputCtdForMs2 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| outputCtdForMs1.setClazz(output); |
| outputCtdForMs2.setClazz(output); |
| ms1.setOutput(outputCtdForMs1); |
| ms2.setOutput(outputCtdForMs2); |
| |
| Collection<?> resultOnC1 = (Collection<?>) OCL.newInstance().evaluate(c1, expression); |
| assertTrue(resultOnC1.isEmpty()); |
| Collection<?> resultOnC2 = (Collection<?>) OCL.newInstance().evaluate(c2, expression); |
| assertEquals(1, resultOnC2.size()); |
| assertTrue(resultOnC2.contains("Output")); |
| |
| final Notification[] noti = new Notification[1]; |
| Adapter adapter = new AdapterImpl() { |
| @Override |
| public void notifyChanged(Notification msg) { |
| noti[0] = msg; |
| } |
| }; |
| output.eAdapters().add(adapter); |
| |
| output.setName("NewOutput"); |
| Collection<?> newResultOnC1 = (Collection<?>) OCL.newInstance().evaluate(c1, expression); |
| assertTrue(newResultOnC1.isEmpty()); |
| Collection<?> newResultOnC2 = (Collection<?>) OCL.newInstance().evaluate(c2, expression); |
| assertEquals(1, newResultOnC2.size()); |
| assertTrue(newResultOnC2.contains("NewOutput")); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti[0]); |
| assertEquals(1, impact.size()); // expecting only c2 to be impacted because c1's ms1's implementation's type doesn't match |
| assertTrue(impact.contains(c2)); |
| } |
| |
| @Test |
| public void testSelectByKindForSubclass() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testSelectByKindForSubclass:\n" + |
| "self.ownedSignatures.implementation->selectByKind(data::classes::SignatureImplementation).implements_.output"+ |
| ".oclAsType(data::classes::ClassTypeDefinition).clazz.name", |
| this.cp).iterator().next().getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c1 = ClassesFactory.eINSTANCE.createSapClass(); |
| c1.setName("c1"); |
| MethodSignature ms1 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms1.setName("ms1"); |
| c1.getOwnedSignatures().add(ms1); |
| SapClass c2 = ClassesFactory.eINSTANCE.createSapClass(); |
| c2.setName("c2"); |
| MethodSignature ms2 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms2.setName("ms2"); |
| c2.getOwnedSignatures().add(ms2); |
| SignatureImplementation ms1Impl = ActionsFactory.eINSTANCE.createBlock(); |
| ms1.setImplementation(ms1Impl); |
| SignatureImplementation ms2Impl = ClassesFactory.eINSTANCE.createLinkSetting(); |
| ms2.setImplementation(ms2Impl); |
| SapClass output = ClassesFactory.eINSTANCE.createSapClass(); |
| output.setName("Output"); |
| ClassTypeDefinition outputCtdForMs1 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ClassTypeDefinition outputCtdForMs2 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| outputCtdForMs1.setClazz(output); |
| outputCtdForMs2.setClazz(output); |
| ms1.setOutput(outputCtdForMs1); |
| ms2.setOutput(outputCtdForMs2); |
| |
| Collection<?> resultOnC1 = (Collection<?>) OCL.newInstance().evaluate(c1, expression); |
| assertEquals(1, resultOnC1.size()); |
| assertTrue(resultOnC1.contains("Output")); |
| Collection<?> resultOnC2 = (Collection<?>) OCL.newInstance().evaluate(c2, expression); |
| assertEquals(1, resultOnC2.size()); |
| assertTrue(resultOnC2.contains("Output")); |
| |
| final Notification[] noti = new Notification[1]; |
| Adapter adapter = new AdapterImpl() { |
| @Override |
| public void notifyChanged(Notification msg) { |
| noti[0] = msg; |
| } |
| }; |
| output.eAdapters().add(adapter); |
| |
| output.setName("NewOutput"); |
| Collection<?> newResultOnC1 = (Collection<?>) OCL.newInstance().evaluate(c1, expression); |
| assertEquals(1, newResultOnC1.size()); |
| assertTrue(newResultOnC1.contains("NewOutput")); |
| Collection<?> newResultOnC2 = (Collection<?>) OCL.newInstance().evaluate(c2, expression); |
| assertEquals(1, newResultOnC2.size()); |
| assertTrue(newResultOnC2.contains("NewOutput")); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti[0]); |
| assertEquals(2, impact.size()); // expecting both, c1 and c2, to be impacted |
| assertTrue(impact.contains(c1)); |
| assertTrue(impact.contains(c2)); |
| } |
| |
| @Test |
| public void testSimpleClosure() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testSimpleClosure:\n" + |
| "self->closure(i | i.ownedSignatures.input.ownedTypeDefinition." + |
| "oclAsType(data::classes::ClassTypeDefinition).clazz)", |
| this.cp).iterator().next().getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c1 = ClassesFactory.eINSTANCE.createSapClass(); |
| c1.setName("c1"); |
| MethodSignature ms1 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms1.setName("ms1"); |
| c1.getOwnedSignatures().add(ms1); |
| Parameter p1 = ClassesFactory.eINSTANCE.createParameter(); |
| p1.setName("p1"); |
| ms1.getInput().add(p1); |
| ClassTypeDefinition ctd1 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| p1.setOwnedTypeDefinition(ctd1); |
| |
| SapClass c2 = ClassesFactory.eINSTANCE.createSapClass(); |
| ctd1.setClazz(c2); |
| c2.setName("c2"); |
| MethodSignature ms2 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms2.setName("ms2"); |
| c2.getOwnedSignatures().add(ms2); |
| Parameter p2 = ClassesFactory.eINSTANCE.createParameter(); |
| p2.setName("p2"); |
| ms2.getInput().add(p2); |
| ClassTypeDefinition ctd2 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| p2.setOwnedTypeDefinition(ctd2); |
| |
| SapClass c3 = ClassesFactory.eINSTANCE.createSapClass(); |
| ctd2.setClazz(c3); |
| c3.setName("c3"); |
| MethodSignature ms3 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms3.setName("ms3"); |
| c3.getOwnedSignatures().add(ms3); |
| Parameter p3 = ClassesFactory.eINSTANCE.createParameter(); |
| p3.setName("p3"); |
| ms3.getInput().add(p3); |
| ClassTypeDefinition ctd3 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| p3.setOwnedTypeDefinition(ctd3); |
| |
| SapClass c4 = ClassesFactory.eINSTANCE.createSapClass(); |
| ctd3.setClazz(c4); |
| c4.setName("c4"); |
| MethodSignature ms4 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms3.setName("ms4"); |
| c4.getOwnedSignatures().add(ms4); |
| |
| Collection<?> resultOnC1 = (Collection<?>) OCL.newInstance().evaluate(c1, expression); |
| assertTrue(resultOnC1.contains(c2)); |
| assertTrue(resultOnC1.contains(c3)); |
| assertTrue(resultOnC1.contains(c4)); |
| |
| final Notification[] noti = new Notification[1]; |
| Adapter adapter = new AdapterImpl() { |
| @Override |
| public void notifyChanged(Notification msg) { |
| noti[0] = msg; |
| } |
| }; |
| ms2.eAdapters().add(adapter); |
| |
| // now add another parameter p22 with new type c5 to ms2; this should change expression |
| // for c2 and c1 whose ms1 argument p1 is using c2 |
| SapClass c5 = ClassesFactory.eINSTANCE.createSapClass(); |
| c5.setName("c5"); |
| Parameter p22 = ClassesFactory.eINSTANCE.createParameter(); |
| p22.setName("p22"); |
| ClassTypeDefinition ctd22 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| p22.setOwnedTypeDefinition(ctd22); |
| ctd22.setClazz(c5); |
| ms2.getInput().add(p22); |
| Collection<?> newResultOnC1 = (Collection<?>) OCL.newInstance().evaluate(c1, expression); |
| assertTrue(newResultOnC1.contains(c2)); |
| assertTrue(newResultOnC1.contains(c3)); |
| assertTrue(newResultOnC1.contains(c4)); |
| assertTrue(newResultOnC1.contains(c5)); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti[0]); |
| assertEquals(2, impact.size()); // expecting c1 and c2 to be impacted |
| assertTrue(impact.contains(c1)); |
| assertTrue(impact.contains(c2)); |
| } |
| |
| @Test |
| public void testResultUseInIterate() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testMoveWithoutImpact:\n" + |
| "Sequence{1, 2, 3}->iterate(i; result:Set(data::classes::SapClass)=Set{self} | result.ownedSignatures.output.oclAsType(data::classes::ClassTypeDefinition).clazz)", |
| this.cp).iterator().next().getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c1 = ClassesFactory.eINSTANCE.createSapClass(); |
| c1.setName("c1"); |
| SapClass c2 = ClassesFactory.eINSTANCE.createSapClass(); |
| c2.setName("c2"); |
| SapClass c3 = ClassesFactory.eINSTANCE.createSapClass(); |
| c3.setName("c3"); |
| SapClass c4 = ClassesFactory.eINSTANCE.createSapClass(); |
| c4.setName("c4"); |
| SapClass c5 = ClassesFactory.eINSTANCE.createSapClass(); |
| c5.setName("c5"); |
| SapClass c6 = ClassesFactory.eINSTANCE.createSapClass(); |
| c6.setName("c6"); |
| |
| connectWithMethodOutput(c1, c2); |
| connectWithMethodOutput(c2, c3); |
| connectWithMethodOutput(c3, c4); |
| connectWithMethodOutput(c4, c5); |
| |
| this.cp.eResource().getContents().add(c1); |
| this.cp.eResource().getContents().add(c2); |
| this.cp.eResource().getContents().add(c3); |
| this.cp.eResource().getContents().add(c4); |
| this.cp.eResource().getContents().add(c5); |
| final Notification[] noti = new Notification[1]; |
| Adapter adapter = new AdapterImpl() { |
| @Override |
| public void notifyChanged(Notification msg) { |
| noti[0] = msg; |
| } |
| }; |
| c5.eAdapters().add(adapter); |
| connectWithMethodOutput(c5, c6); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti[0]); |
| assertEquals(5, impact.size()); // expecting all c1..c6 to be impacted |
| assertFalse(impact.contains(c6)); |
| } |
| |
| private void connectWithMethodOutput(SapClass c1, SapClass c2) { |
| MethodSignature m1 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| m1.setName("m1"); |
| ClassTypeDefinition ctd1 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ctd1.setClazz(c2); |
| m1.setOutput(ctd1); |
| c1.getOwnedSignatures().add(m1); |
| } |
| |
| @Test |
| public void testMoveWithoutImpact() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testMoveWithoutImpact:\n" + "self.ownedSignatures->at(3).name = 'm3'", |
| this.cp).iterator().next().getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c = ClassesFactory.eINSTANCE.createSapClass(); |
| MethodSignature m1 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| m1.setName("m1"); |
| c.getOwnedSignatures().add(m1); |
| MethodSignature m2 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| m2.setName("m2"); |
| c.getOwnedSignatures().add(m2); |
| MethodSignature m3 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| m1.setName("m3"); |
| c.getOwnedSignatures().add(m3); |
| this.cp.eResource().getContents().add(c); |
| c.setName("C"); |
| final Notification[] noti = new Notification[1]; |
| Adapter adapter = new AdapterImpl() { |
| @Override |
| public void notifyChanged(Notification msg) { |
| noti[0] = msg; |
| } |
| }; |
| c.eAdapters().add(adapter); |
| c.getOwnedSignatures().move(0, 1); // swap first two signatures |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti[0]); |
| assertEquals(0, impact.size()); |
| c.getOwnedSignatures().move(1, 2); // not the name of the element at position 3 should have changed |
| Collection<EObject> impact2 = ia.getContextObjects(noti[0]); |
| assertEquals(1, impact2.size()); |
| assertTrue(impact2.contains(c)); |
| } |
| |
| @Test |
| public void testTupleLiteralUsedTwice() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testTupleLiteralUsedTwice:\n" |
| + "let t:Tuple(c:data::classes::SapClass, d:data::classes::SapClass) = Tuple{c=self, d=self.adapters.to->first()} in\n" |
| + "Set{t.c.name, t.d.name}", this.cp).iterator().next().getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c = ClassesFactory.eINSTANCE.createSapClass(); |
| SapClass d = ClassesFactory.eINSTANCE.createSapClass(); |
| d.setName("D"); |
| this.cp.eResource().getContents().add(c); |
| c.setName("oldName"); |
| TypeAdapter ta = ClassesFactory.eINSTANCE.createTypeAdapter(); |
| ta.setAdapted(c); |
| ta.setTo(d); |
| EAttribute att = (EAttribute) c.eClass().getEStructuralFeature(ClassesPackage.SAP_CLASS__NAME); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(c, att, "oldName", "newName"); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| assertEquals(1, impact.size()); |
| assertTrue(impact.contains(c)); |
| Notification noti2 = NotificationHelper.createAttributeChangeNotification(d, att, "D", "newD"); |
| Collection<EObject> impact2 = ia.getContextObjects(noti2); |
| assertTrue(impact2.size() == 2 && impact2.contains(c) && impact2.contains(d)); |
| } |
| |
| @Test |
| public void testTupleLiteralWithImmediatePropertyCall() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testTupleLiteralWithImmediatePropertyCall:\n" + "Tuple{c=self}.c.name", |
| this.cp).iterator().next().getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c = ClassesFactory.eINSTANCE.createSapClass(); |
| this.cp.eResource().getContents().add(c); |
| c.setName("oldName"); |
| EAttribute att = (EAttribute) c.eClass().getEStructuralFeature(ClassesPackage.SAP_CLASS__NAME); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(c, att, "oldName", "newName"); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| assertEquals(1, impact.size()); |
| assertTrue(impact.contains(c)); |
| } |
| |
| @Test |
| public void testTupleLiteralPassedThroughLetVariable() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testTupleLiteralPassedThroughLetVariable:\n" |
| + "let t:Tuple(c:data::classes::SapClass) = Tuple{c=self} in\n" + "t.c.name", this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c = ClassesFactory.eINSTANCE.createSapClass(); |
| this.cp.eResource().getContents().add(c); |
| c.setName("oldName"); |
| EAttribute att = (EAttribute) c.eClass().getEStructuralFeature(ClassesPackage.SAP_CLASS__NAME); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(c, att, "oldName", "newName"); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| assertEquals(1, impact.size()); |
| assertTrue(impact.contains(c)); |
| } |
| |
| @Test |
| public void testTupleLiteralPassedThroughTwoLetVariables() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testTupleLiteralPassedThroughLetVariable:\n" |
| + "let t1:Tuple(c:data::classes::SapClass) = Tuple{c=self} in\n" |
| + "let t2:Tuple(c:data::classes::SapClass) = t1 in\n" + "t2.c.name", this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c = ClassesFactory.eINSTANCE.createSapClass(); |
| this.cp.eResource().getContents().add(c); |
| c.setName("oldName"); |
| EAttribute att = (EAttribute) c.eClass().getEStructuralFeature(ClassesPackage.SAP_CLASS__NAME); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(c, att, "oldName", "newName"); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| assertEquals(1, impact.size()); |
| assertTrue(impact.contains(c)); |
| } |
| |
| @Test |
| public void testNestedTupleLiteral() { |
| OCLExpression expression = (OCLExpression) parse( |
| "context data::classes::SapClass inv testNestedTupleLiteral:\n" |
| + "Tuple{c:Tuple(d:data::classes::SapClass)=Tuple{d=self}}.c.d.name", this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| SapClass c = ClassesFactory.eINSTANCE.createSapClass(); |
| this.cp.eResource().getContents().add(c); |
| c.setName("oldName"); |
| EAttribute att = (EAttribute) c.eClass().getEStructuralFeature(ClassesPackage.SAP_CLASS__NAME); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(c, att, "oldName", "newName"); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| assertEquals(1, impact.size()); |
| assertTrue(impact.contains(c)); |
| } |
| |
| @Test |
| public void testLongRunningNavigationPathConstruction() { |
| OCLExpression expression = (OCLExpression) parse(testLongRunningNavigationPathExpression, this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(expression); |
| AssociationEnd ae = ClassesFactory.eINSTANCE.createAssociationEnd(); |
| this.cp.eResource().getContents().add(ae); |
| EAttribute att = (EAttribute) ae.eClass().getEStructuralFeature(ClassesPackage.ASSOCIATION_END__NAME); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(ae, att, "oldName", "newName"); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(expression, ClassesPackage.eINSTANCE |
| .getAssociationEnd(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| assertTrue(impact.size() == 1 && impact.contains(ae)); |
| } |
| |
| /** |
| * self.ownerTypedElement.oclAsType(MethodCallExpression).methodSignature.output.lowerMultiplicity * |
| * self.ownerTypedElement.oclAsType(MethodCallExpression).object.getType().lowerMultiplicity |
| */ |
| |
| @Test |
| public void testLowerMultiplicityPropagationForMethodCallOnParameterUsage() { |
| OCLExpression exp = (OCLExpression) parse(testLowerMultiplicityPropagationForMethodCall, this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| Resource r = this.cp.eResource(); |
| r.eAdapters().add(new ECrossReferenceAdapter()); |
| r.getContents().add(exp); |
| // construct something like "abc".length(), then change multiplicity of "abc" from 1..1 to 0..1 |
| MethodSignature length = ClassesFactory.eINSTANCE.createMethodSignature(); |
| r.getContents().add(length); |
| length.setName("length"); |
| SapClass numberClass = ClassesFactory.eINSTANCE.createSapClass(); |
| r.getContents().add(numberClass); |
| numberClass.setName("Number"); |
| ClassTypeDefinition msOutput = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| msOutput.setClazz(numberClass); |
| msOutput.setLowerMultiplicity(1); |
| msOutput.setUpperMultiplicity(1); |
| length.setOutput(msOutput); |
| ClassTypeDefinition ctd = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ctd.setClazz(numberClass); |
| ctd.setLowerMultiplicity(1); |
| ctd.setUpperMultiplicity(1); |
| MethodCallExpression mce = ExpressionsFactory.eINSTANCE.createMethodCallExpression(); |
| r.getContents().add(mce); |
| mce.setOwnedTypeDefinition(ctd); |
| mce.setMethodSignature(length); |
| Parameter p = ClassesFactory.eINSTANCE.createParameter(); |
| r.getContents().add(p); |
| p.setName("p"); |
| SapClass stringClass = ClassesFactory.eINSTANCE.createSapClass(); |
| r.getContents().add(stringClass); |
| stringClass.setName("String"); |
| ClassTypeDefinition otDef = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| otDef.setClazz(stringClass); |
| otDef.setUpperMultiplicity(1); |
| otDef.setLowerMultiplicity(1); |
| p.setOwnedTypeDefinition(otDef); |
| VariableExpression ve = ExpressionsFactory.eINSTANCE.createVariableExpression(); |
| ve.setVariable(p); // this should infer the variable expression's multiplicity to that of p |
| mce.setObject(ve); |
| |
| assertEquals(1, ve.getType().getLowerMultiplicity()); |
| |
| OCL ocl = org.eclipse.ocl.examples.impactanalyzer.util.OCL.newInstance(); |
| Object oldResult = ocl.evaluate(ctd, exp); |
| Notification noti = NotificationHelper.createChangeLowerMultiplicityNotification(p.getOwnedTypeDefinition(), 0); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, ClassesPackage.eINSTANCE |
| .getClassTypeDefinition(), /* notifyOnNewContextElements */ false, |
| OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| Object newResult = ocl.evaluate(ctd, exp); |
| |
| assertEquals(0, p.getOwnedTypeDefinition().getLowerMultiplicity()); |
| assertFalse("expected " + oldResult + " and " + newResult + " to be different but were equal", oldResult |
| .equals(newResult)); |
| assertEquals(1, impact.size()); |
| assertTrue(impact.contains(ctd)); |
| |
| } |
| |
| /** |
| * self.ownerTypedElement.oclAsType(MethodCallExpression).methodSignature.output.lowerMultiplicity * |
| * self.ownerTypedElement.oclAsType(MethodCallExpression).object.getType().lowerMultiplicity |
| */ |
| @Test |
| public void testLowerMultiplicityPropagationForMethodCall() { |
| OCLExpression exp = (OCLExpression) parse(testLowerMultiplicityPropagationForMethodCall, this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| Resource r = this.cp.eResource(); |
| r.getContents().add(exp); |
| // construct something like "abc".length(), then change multiplicity of "abc" from 1..1 to 0..1 |
| MethodSignature length = ClassesFactory.eINSTANCE.createMethodSignature(); |
| length.setName("length"); |
| SapClass numberClass = ClassesFactory.eINSTANCE.createSapClass(); |
| numberClass.setName("Number"); |
| ClassTypeDefinition msOutput = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| msOutput.setClazz(numberClass); |
| msOutput.setLowerMultiplicity(1); |
| msOutput.setUpperMultiplicity(1); |
| length.setOutput(msOutput); |
| ClassTypeDefinition ctd1 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ctd1.setClazz(numberClass); |
| ctd1.setLowerMultiplicity(1); |
| ctd1.setUpperMultiplicity(1); |
| MethodCallExpression mce = ExpressionsFactory.eINSTANCE.createMethodCallExpression(); |
| mce.setOwnedTypeDefinition(ctd1); |
| mce.setMethodSignature(length); |
| StringLiteral sl = LiteralsFactory.eINSTANCE.createStringLiteral(); |
| sl.setLiteral("abc"); |
| SapClass stringClass = ClassesFactory.eINSTANCE.createSapClass(); |
| ClassTypeDefinition ctd2 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ctd2.setClazz(stringClass); |
| ctd2.setLowerMultiplicity(1); |
| ctd2.setUpperMultiplicity(1); |
| sl.setOwnedTypeDefinition(ctd2); |
| mce.setObject(sl); |
| |
| r.getContents().add(mce); |
| r.getContents().add(length); |
| r.getContents().add(numberClass); |
| r.getContents().add(stringClass); |
| |
| assertEquals(1, sl.getOwnedTypeDefinition().getLowerMultiplicity()); |
| |
| Notification noti = NotificationHelper.createChangeLowerMultiplicityNotification(sl.getOwnedTypeDefinition(), 0); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, ClassesPackage.eINSTANCE |
| .getClassTypeDefinition(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| |
| assertEquals(0, sl.getOwnedTypeDefinition().getLowerMultiplicity()); |
| assertEquals(1, impact.size()); |
| assertTrue(impact.contains(ctd1)); |
| |
| } |
| |
| /** |
| * data::classes::SapClass.allInstances()->select(c | c.name = 'something' |
| */ |
| @Test |
| public void testAnalysisOfRecursiveOperationWithSelf() { |
| OCLExpression exp = (OCLExpression) parse(testAnalysisOfRecursiveOperationWithSelf, this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| Resource r = this.cp.eResource(); |
| |
| r.eAdapters().add(new ECrossReferenceAdapter()); |
| r.getContents().add(exp); |
| |
| // construct something like "new HumbaClass1().m()" |
| final SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| cl1.setName("Alice"); |
| MethodSignature ms = ClassesFactory.eINSTANCE.createMethodSignature(); |
| ms.setName("testMethod"); |
| cl1.getOwnedSignatures().add(ms); |
| final ClassTypeDefinition ctd = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ctd.setLowerMultiplicity(1); |
| ctd.setUpperMultiplicity(1); |
| ctd.setClazz(null); |
| final MethodCallExpression mce = ExpressionsFactory.eINSTANCE.createMethodCallExpression(); |
| final ObjectCreationExpression oce = ExpressionsFactory.eINSTANCE.createObjectCreationExpression(); |
| oce.setClassToInstantiate(cl1); |
| oce.setOwnedTypeDefinition(ctd); |
| mce.setObject(oce); |
| |
| r.getContents().add(cl1); |
| r.getContents().add(mce); |
| |
| Notification noti = NotificationHelper.createChangeClazzNotification(ctd, cl1); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, ExpressionsPackage.eINSTANCE |
| .getMethodCallExpression(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| |
| assertEquals(1, impact.size()); |
| assertTrue(impact.contains(mce) && !impact.contains(ctd)); |
| |
| } |
| |
| /** |
| * data::classes::SapClass.allInstances()->select(c | c.name = 'something' |
| */ |
| @Test |
| public void testAllInstancesSelectClassName() { |
| Resource r = this.cp.eResource(); |
| OCLExpression exp = (OCLExpression) parse(testAllInstancesSelectClassName, this.cp).iterator().next().getSpecification() |
| .getBodyExpression(); |
| r.getContents().add(exp); |
| final SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| cl1.setName("Alice"); |
| r.getContents().add(cl1); |
| final ClassTypeDefinition ctd = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ctd.setClazz(cl1); |
| r.getContents().add(ctd); |
| |
| EAttribute att = (EAttribute) cl1.eClass().getEStructuralFeature(ClassesPackage.SAP_CLASS__NAME); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(cl1, att, "Alice", "Bob"); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, |
| ClassesPackage.eINSTANCE.getClassTypeDefinition(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| // The expression has as its context ClassTypeDefinition. Therefore, the SapClass must not be returned |
| // as impacted object. However, the change affects the ->select clause after allInstances(), so |
| // all context objects of type ClassTypeDefinition are affected. That's what we want to assert now: |
| assertTrue(impact.size() > 0 && impact.contains(ctd) && !impact.contains(cl1)); |
| } |
| |
| /** |
| * The ->select lets only classes pass whose name is 'Bob'. Therefore, a class named 'Alice' |
| * should not be produced by any context. |
| */ |
| @Test |
| public void testFindContextElementsForResultForAllInstances() { |
| Resource r = this.cp.eResource(); |
| OCLExpression exp = (OCLExpression) parse(testAllInstancesSelectClassName, this.cp).iterator().next().getSpecification() |
| .getBodyExpression(); |
| r.getContents().add(exp); |
| final SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| cl1.setName("Alice"); |
| r.getContents().add(cl1); |
| final ClassTypeDefinition ctd = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ctd.setClazz(cl1); |
| r.getContents().add(ctd); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, |
| ClassesPackage.eINSTANCE.getClassTypeDefinition(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> contexts = ia.getContextObjects(cl1); |
| assertTrue(contexts.isEmpty()); |
| } |
| |
| /** |
| * The ->select lets only classes pass whose name is 'Bob'. Therefore, a class named 'Bob' |
| * should be produced by all possible contexts |
| */ |
| @Test |
| public void testFindAllContextElementsForResultForAllInstances() { |
| Resource r = this.cp.eResource(); |
| OCLExpression exp = (OCLExpression) parse(testAllInstancesSelectClassName, this.cp).iterator().next().getSpecification() |
| .getBodyExpression(); |
| r.getContents().add(exp); |
| final SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| cl1.setName("Bob"); |
| r.getContents().add(cl1); |
| final ClassTypeDefinition ctd = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| ctd.setClazz(cl1); |
| r.getContents().add(ctd); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, |
| ClassesPackage.eINSTANCE.getClassTypeDefinition(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> contexts = ia.getContextObjects(cl1); |
| assertTrue(!contexts.isEmpty()); |
| assertTrue(contexts.contains(ctd)); |
| } |
| |
| /** |
| * data::classes::SapClass.allInstances()->select(c | c.name = 'something' |
| */ |
| @Test |
| public void testTriggeringAllInstancesByDirectResourceContainment() { |
| Resource r = this.cp.eResource(); |
| OCLExpression exp = (OCLExpression) parse(testAllInstancesSelectClassName, this.cp).iterator().next().getSpecification() |
| .getBodyExpression(); |
| r.getContents().add(exp); |
| final ClassTypeDefinition ctd = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| r.getContents().add(ctd); |
| final SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| cl1.setName("Bob"); |
| final Notification[] notifications = new Notification[1]; |
| Adapter a = new AdapterImpl() { |
| @Override |
| public void notifyChanged(Notification n) { |
| if (n.getEventType() != Notification.REMOVING_ADAPTER) { |
| if (notifications[0] != null) { |
| fail("didn't expect to receive two notifications"); |
| } |
| notifications[0] = n; |
| } |
| } |
| }; |
| r.eAdapters().add(a); |
| cl1.eAdapters().add(a); |
| r.getContents().add(cl1); |
| assertNotNull("Expected to receive one notification", notifications[0]); |
| r.eAdapters().remove(a); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, ClassesPackage.eINSTANCE.getClassTypeDefinition(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(notifications[0]); |
| // The expression has as its context ClassTypeDefinition. Therefore, the SapClass must not be returned |
| // as impacted object. However, the change affects the ->select clause after allInstances(), so |
| // all context objects of type ClassTypeDefinition are affected. That's what we want to assert now: |
| assertTrue(impact.size() > 0 && impact.contains(ctd) && !impact.contains(cl1)); |
| } |
| |
| @Test |
| public void testVerySimpleTracerBasedInstanceScopeAnalysisWithNewClassScopeAnalysis() { |
| Resource r = this.cp.eResource(); |
| OCLExpression exp = (OCLExpression) parse(testVerySimpleTracerBasedInstanceScopeAnalysisWithNewClassScopeAnalysis, |
| this.cp).iterator().next().getSpecification().getBodyExpression(); |
| r.getContents().add(exp); |
| |
| final SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| cl1.setName("Alice"); |
| r.getContents().add(cl1); |
| |
| EAttribute att = (EAttribute) cl1.eClass().getEStructuralFeature(ClassesPackage.SAP_CLASS__NAME); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(cl1, att, "Alice", "Bob"); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, ClassesPackage.eINSTANCE.getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| |
| assertTrue(impact.size() == 1 && impact.contains(cl1)); |
| } |
| |
| @Test |
| public void testInstanceScopeAnalysisForRecursiveOperation() { |
| Resource r = this.cp.eResource(); |
| OCLExpression exp = (OCLExpression) parse(testInstanceScopeAnalysisForRecursiveOperation, this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| r.getContents().add(exp); |
| |
| final SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| cl1.setName("Alice"); |
| r.getContents().add(cl1); |
| SapClass cl2 = ClassesFactory.eINSTANCE.createSapClass(); |
| ; |
| cl2.setName("Bob"); |
| r.getContents().add(cl2); |
| TypeAdapter adapter = ClassesFactory.eINSTANCE.createTypeAdapter(); |
| adapter.setName("Alice_to_Bob_Adapter"); |
| adapter.setAdapted(cl1); |
| // the adapted reference already is a container |
| // r.getContents().add(adapter); |
| |
| EReference ref1 = (EReference) adapter.eClass().getEStructuralFeature(ClassesPackage.TYPE_ADAPTER__TO); |
| Notification noti1 = NotificationHelper.createReferenceChangeNotification(adapter, ref1, null, cl2); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, ClassesPackage.eINSTANCE.getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact1 = ia.getContextObjects(noti1); |
| |
| assertTrue(impact1.size() == 1 && impact1.contains(cl1)); |
| } |
| |
| @Test |
| public void testVerySimpleInstanceScopeAnalysisWithTupleUsingSelf() { |
| Resource r = this.cp.eResource(); |
| OCLExpression exp = (OCLExpression) parse(testVerySimpleInstanceScopeAnalysisWithTupleUsingSelf, this.cp).iterator() |
| .next().getSpecification().getBodyExpression(); |
| r.getContents().add(exp); |
| |
| final SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| cl1.setName("Alice"); |
| r.getContents().add(cl1); |
| |
| EAttribute att = (EAttribute) cl1.eClass().getEStructuralFeature(ClassesPackage.SAP_CLASS__NAME); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(cl1, att, "Alice", "Bob"); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, ClassesPackage.eINSTANCE.getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| assertEquals(1, impact.size()); |
| assertTrue(impact.contains(cl1)); |
| } |
| |
| @Test |
| public void testVerySimpleInstanceScopeAnalysisWithTuple() { |
| Resource r = this.cp.eResource(); |
| OCLExpression exp = (OCLExpression) parse(testVerySimpleInstanceScopeAnalysisWithTuple, this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| r.getContents().add(exp); |
| |
| final SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| cl1.setName("Alice"); |
| r.getContents().add(cl1); |
| |
| EAttribute att = (EAttribute) cl1.eClass().getEStructuralFeature(ClassesPackage.SAP_CLASS__NAME); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(cl1, att, "Alice", "Bob"); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, ClassesPackage.eINSTANCE.getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| |
| assertTrue(impact.size() == 1 && impact.contains(cl1)); |
| } |
| |
| @Test |
| public void testGetFloorTokenNull() { |
| Resource r = this.cp.eResource(); |
| OCLExpression exp = (OCLExpression) parse(testForIA2, this.cp).iterator().next().getSpecification().getBodyExpression(); |
| |
| SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| r.getContents().add(cl1); |
| cl1.setName("Alice"); |
| cl1.setValueType(true); |
| |
| ClassTypeDefinition ctd1 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| r.getContents().add(ctd1); |
| ctd1.setClazz(cl1); |
| ctd1.setLowerMultiplicity(1); |
| ctd1.setUpperMultiplicity(1); |
| ctd1.setOrdered(false); |
| ctd1.setUnique(false); |
| |
| SapClass cl2 = ClassesFactory.eINSTANCE.createSapClass(); |
| r.getContents().add(cl2); |
| cl2.setName("Bob"); |
| |
| ClassTypeDefinition ctd2 = ClassesFactory.eINSTANCE.createClassTypeDefinition(); |
| r.getContents().add(ctd2); |
| ctd2.setClazz(cl2); |
| ctd2.setLowerMultiplicity(1); |
| ctd2.setUpperMultiplicity(1); |
| ctd2.setOrdered(false); |
| ctd2.setUnique(false); |
| |
| ObjectLiteral ol1 = LiteralsFactory.eINSTANCE.createObjectLiteral(); |
| r.getContents().add(ol1); |
| ol1.setValueClass(cl1); |
| |
| AssociationEnd ae1 = ClassesFactory.eINSTANCE.createAssociationEnd(); |
| r.getContents().add(ae1); |
| ae1.setName("Assoc_to_Alice"); |
| ae1.setType(ctd1); |
| |
| AssociationEnd ae2 = ClassesFactory.eINSTANCE.createAssociationEnd(); |
| r.getContents().add(ae2); |
| ae2.setName("Assoc_to_Bob"); |
| ae2.setType(ctd2); |
| |
| Association a = ClassesFactory.eINSTANCE.createAssociation(); |
| r.getContents().add(a); |
| a.setName("Assoc"); |
| a.getEnds().add(ae1); |
| a.getEnds().add(ae2); |
| |
| EAttribute att = (EAttribute) ae1.eClass().getEStructuralFeature(ClassesPackage.ASSOCIATION_END__NAME); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(ae2, att, "Assoc_to_Bob", |
| "Assoc_to_Bob_changed"); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE |
| .createImpactAnalyzer(exp, LiteralsPackage.eINSTANCE.getObjectLiteral(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| assertEquals(1, impact.size()); |
| assertTrue(impact.contains(ol1)); |
| } |
| |
| @Test |
| public void testPredicateEvaluation() { |
| OCLExpression exp = (OCLExpression) parse( |
| "context data::classes::SapClass inv testPredicateEvaluation:\n" |
| + "self.ownedSignatures->select(s|s.sideEffectFree)->size() > 1", this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(exp); |
| SapClass c1 = ClassesFactory.eINSTANCE.createSapClass(); |
| c1.setName("c1"); |
| SapClass c2 = ClassesFactory.eINSTANCE.createSapClass(); |
| c2.setName("c2"); |
| SapClass c3 = ClassesFactory.eINSTANCE.createSapClass(); |
| c3.setName("c3"); |
| MethodSignature m1 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| m1.setName("Signature 1"); |
| m1.setSideEffectFree(true); |
| MethodSignature m2 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| m2.setName("Signature 2"); |
| m2.setSideEffectFree(false); |
| MethodSignature m3 = ClassesFactory.eINSTANCE.createMethodSignature(); |
| m3.setName("Signature 3"); |
| m3.setSideEffectFree(true); |
| |
| c1.getOwnedSignatures().add(m1); |
| c2.getOwnedSignatures().add(m2); |
| c3.getOwnedSignatures().add(m3); |
| |
| EAttribute att = (EAttribute) m3.eClass().getEStructuralFeature(ClassesPackage.METHOD_SIGNATURE__SIDE_EFFECT_FREE); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(m3, att, true, false); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| assertTrue(impact.size() == 1 && impact.contains(c3)); |
| |
| noti = NotificationHelper.createAttributeChangeNotification(m3, att, false, true); |
| impact = ia.getContextObjects(noti); |
| assertTrue(impact.size() == 1 && impact.contains(c3)); |
| |
| noti = NotificationHelper.createAttributeChangeNotification(m3, att, false, false); |
| impact = ia.getContextObjects(noti); |
| assertTrue(impact.size() == 0); |
| |
| noti = NotificationHelper.createAttributeChangeNotification(m3, att, true, true); |
| impact = ia.getContextObjects(noti); |
| assertTrue(impact.size() == 0); |
| } |
| |
| @Test |
| public void testDeltaPropagationForAllInstances() { |
| OCLExpression exp = (OCLExpression) parse( |
| "context data::classes::SapClass inv testDeltaPropagationForAllInstances:\n" |
| + "data::classes::SapClass.allInstances()->select(name='Humba')->size() = 0", this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| this.cp.eResource().getContents().add(exp); |
| SapClass c1 = ClassesFactory.eINSTANCE.createSapClass(); |
| c1.setName("Trala"); |
| SapClass c2 = ClassesFactory.eINSTANCE.createSapClass(); |
| c2.setName("Humba"); |
| modelmanagement.Package pkg = ModelmanagementFactory.eINSTANCE.createPackage(); |
| pkg.setName("Pkg"); |
| this.cp.eResource().getContents().add(pkg); |
| Notification noti = NotificationHelper.createReferenceAddNotification(pkg, ModelmanagementPackage.eINSTANCE |
| .getPackage_Classes(), c1); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, ClassesPackage.eINSTANCE.getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| assertEquals(0, impact.size()); |
| |
| noti = NotificationHelper.createReferenceAddNotification(pkg, ModelmanagementPackage.eINSTANCE.getPackage_Classes(), c2); |
| impact = ia.getContextObjects(noti); |
| assertTrue(impact.size() >= 2); // we don't know the exact size because of all the other test elements created for fixture |
| assertTrue(impact.contains(c1) && impact.contains(c2)); |
| } |
| |
| @Test |
| public void testSimpleUnusedCheckWithIfConditionAlwaysFalse() { |
| Resource r = this.cp.eResource(); |
| OCLExpression exp = (OCLExpression) parse("context data::classes::SapClass inv testSimpleUnusedCheckWithIfClause:\n"+ |
| "if false then self.valueType else true endif", this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| r.getContents().add(exp); |
| |
| final SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| cl1.setValueType(false); |
| r.getContents().add(cl1); |
| |
| EAttribute att = (EAttribute) cl1.eClass().getEStructuralFeature(ClassesPackage.SAP_CLASS__VALUE_TYPE); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(cl1, att, false, true); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, ClassesPackage.eINSTANCE.getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| |
| if (OptimizationActivation.getOption().isTracebackStepISAActive() && OptimizationActivation.getOption().isUnusedDetectionActive()) { |
| // expecting no impact because the then clause affected by the change is unused |
| assertEquals(0, impact.size()); |
| } else { |
| assertEquals(1, impact.size()); |
| assertEquals(cl1, impact.iterator().next()); |
| } |
| } |
| |
| @Test |
| public void testSimpleUnusedCheckWithIteratorSourceAlwaysEmpty() { |
| Resource r = this.cp.eResource(); |
| // the idea: while self.valueType changes for cl1, self.adapters is always empty for the changed object |
| OCLExpression exp = (OCLExpression) parse("context data::classes::SapClass inv testSimpleUnusedCheckWithIfClause:\n"+ |
| "self.adapters->select(a | a.to.valueType = self.valueType)", this.cp).iterator().next() |
| .getSpecification().getBodyExpression(); |
| r.getContents().add(exp); |
| |
| final SapClass cl1 = ClassesFactory.eINSTANCE.createSapClass(); |
| cl1.setValueType(false); |
| r.getContents().add(cl1); |
| |
| EAttribute att = (EAttribute) cl1.eClass().getEStructuralFeature(ClassesPackage.SAP_CLASS__VALUE_TYPE); |
| Notification noti = NotificationHelper.createAttributeChangeNotification(cl1, att, false, true); |
| ImpactAnalyzer ia = ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer(exp, ClassesPackage.eINSTANCE.getSapClass(), /* notifyOnNewContextElements */ false, OCLFactory.getInstance()); |
| Collection<EObject> impact = ia.getContextObjects(noti); |
| |
| if (OptimizationActivation.getOption().isUnusedDetectionActive()) { |
| // expecting no impact because the then clause affected by the change is unused |
| assertEquals(0, impact.size()); |
| } else { |
| assertEquals(1, impact.size()); |
| assertEquals(cl1, impact.iterator().next()); |
| } |
| } |
| |
| } |
