| /******************************************************************************* |
| * Copyright (c) 2008 E.D.Willink 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: |
| * E.D.Willink - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.qvt.declarative.test.emof.qvtbase; |
| |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import junit.framework.AssertionFailedError; |
| |
| import org.eclipse.emf.common.util.DiagnosticChain; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EClassifier; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.EValidator; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl; |
| import org.eclipse.emf.ecore.util.Diagnostician; |
| import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl; |
| import org.eclipse.ocl.lpg.AbstractProblemHandler; |
| import org.eclipse.ocl.lpg.ProblemHandler; |
| import org.eclipse.ocl.lpg.StringProblemHandler; |
| import org.eclipse.qvt.declarative.ecore.QVTBase.Function; |
| import org.eclipse.qvt.declarative.ecore.QVTBase.FunctionParameter; |
| import org.eclipse.qvt.declarative.ecore.QVTBase.Pattern; |
| import org.eclipse.qvt.declarative.ecore.QVTBase.Predicate; |
| import org.eclipse.qvt.declarative.ecore.QVTBase.QVTBaseFactory; |
| import org.eclipse.qvt.declarative.ecore.QVTBase.QVTBasePackage; |
| import org.eclipse.qvt.declarative.ecore.QVTBase.Transformation; |
| import org.eclipse.qvt.declarative.ecore.QVTBase.TypedModel; |
| import org.eclipse.qvt.declarative.parser.environment.ProblemHandlerDiagnosticChain; |
| import org.eclipse.qvt.declarative.parser.utils.ProblemLog; |
| import org.eclipse.qvt.declarative.parser.utils.ProblemLog.Problem; |
| import org.eclipse.qvt.declarative.test.TestQVTBase.TestDomain; |
| import org.eclipse.qvt.declarative.test.TestQVTBase.TestExpression; |
| import org.eclipse.qvt.declarative.test.TestQVTBase.TestPattern; |
| import org.eclipse.qvt.declarative.test.TestQVTBase.TestQVTBaseFactory; |
| import org.eclipse.qvt.declarative.test.TestQVTBase.TestRule; |
| import org.eclipse.qvt.declarative.test.TestQVTBase.TestTransformation; |
| import org.eclipse.qvt.declarative.test.emof.essentialocl.AbstractEssentialOCLValidationTest; |
| import org.eclipse.qvt.declarative.test.emof.utils.TestFormattingHelper; |
| |
| public abstract class AbstractQVTBaseValidationTest extends AbstractEssentialOCLValidationTest |
| { |
| public static final QVTBaseFactory QVTb_Factory = QVTBaseFactory.eINSTANCE; |
| |
| /** |
| * Asserts that two objects are equal. If they are not |
| * an AssertionFailedError is thrown. |
| */ |
| static public void assertEquals(ProblemLog expectedProblemLog, ProblemLog actualProblemLog) { |
| try { |
| int actualTotalProblems = actualProblemLog.getAllProblems(); |
| int expectedTotalProblems = expectedProblemLog.getAllProblems(); |
| assertEquals("Total Problem count", expectedTotalProblems, actualTotalProblems); |
| Set<ProblemHandler.Phase> actualProcessingPhases = actualProblemLog.getProcessingPhases(); |
| Set<ProblemHandler.Phase> expectedProcessingPhases = expectedProblemLog.getProcessingPhases(); |
| if (!actualProcessingPhases.equals(expectedProcessingPhases)) { |
| assertEquals("Processing Phases", expectedProcessingPhases, actualProcessingPhases); |
| } |
| for (ProblemHandler.Phase processingPhase : actualProcessingPhases) { |
| Map<ProblemHandler.Severity, List<Problem>> actualPhaseProblems = actualProblemLog.getProblems(processingPhase); |
| Map<ProblemHandler.Severity, List<Problem>> expectedPhaseProblems = expectedProblemLog.getProblems(processingPhase); |
| Set<ProblemHandler.Severity> actualSeverities = actualPhaseProblems.keySet(); |
| Set<ProblemHandler.Severity> expectedSeverities = expectedPhaseProblems.keySet(); |
| if (!actualSeverities.equals(expectedSeverities)) { |
| assertEquals("Processing Severities", expectedSeverities, actualSeverities); |
| } |
| for (ProblemHandler.Severity severity : actualSeverities) { |
| List<Problem> actualProblems = actualPhaseProblems.get(severity); |
| List<Problem> expectedProblems = expectedPhaseProblems.get(severity); |
| Collections.sort(actualProblems); |
| Collections.sort(expectedProblems); |
| int actualProblemCount = actualProblems.size(); |
| int expectedProblemCount = expectedProblems.size(); |
| assertEquals("Problem count", expectedProblemCount, actualProblemCount); |
| for (int i = 0; i < actualProblemCount; i++) { |
| Problem actualProblem = actualProblems.get(i); |
| Problem expectedProblem = expectedProblems.get(i); |
| assertEquals("Problem message", expectedProblem.problemMessage, actualProblem.problemMessage); |
| assertEquals("Problem processingContext", expectedProblem.processingContext, actualProblem.processingContext); |
| if (expectedProblem.startOffset >= 0) |
| assertEquals("Problem startOffset", expectedProblem.startOffset, actualProblem.startOffset); |
| if (expectedProblem.endOffset >= 0) |
| assertEquals("Problem endOffset", expectedProblem.endOffset, actualProblem.endOffset); |
| } |
| } |
| } |
| } catch (AssertionFailedError e) { |
| StringBuffer s = new StringBuffer(); |
| s.append(e.getMessage()); |
| s.append("\nExpected"); |
| expectedProblemLog.toString(s, " "); |
| s.append("\nActual"); |
| actualProblemLog.toString(s, " "); |
| throw new AssertionFailedError(s.toString()); |
| } |
| } |
| |
| protected boolean copyErrorToConsole = false; // True to put error message on console as well as JUnit failure |
| protected ResourceSet resourceSet; |
| protected Resource resource; |
| |
| protected Diagnostician createDiagnostician() { |
| return new Diagnostician() |
| { |
| @Override |
| protected boolean doValidateContents(EObject object, DiagnosticChain diagnostics, Map<Object, Object> context) { |
| if (object.eClass().getEPackage() == org.eclipse.ocl.ecore.EcorePackage.eINSTANCE) |
| return true; // OCL's ValidatorVisitor does its own child traversal |
| else |
| return super.doValidateContents(object, diagnostics, context); |
| } |
| }; |
| } |
| |
| protected Function createFunction(Transformation transformation, String name) { |
| Function function = QVTb_Factory.createFunction(); |
| function.setName(name); |
| if (transformation != null) |
| transformation.getEOperations().add(function); |
| return function; |
| } |
| |
| protected FunctionParameter createFunctionParameter(Function function, String name, EClassifier eType) { |
| FunctionParameter functionParameter = QVTb_Factory.createFunctionParameter(); |
| functionParameter.setName(name); |
| functionParameter.setEType(eType); |
| if (function != null) |
| function.getEParameters().add(functionParameter); |
| return functionParameter; |
| } |
| |
| protected Pattern createPattern(List<? super Pattern> patterns) { |
| Pattern pattern = QVTb_Factory.createPattern(); |
| if (patterns != null) |
| patterns.add(pattern); |
| return pattern; |
| } |
| |
| protected Predicate createPredicate(List<? super Predicate> predicates) { |
| Predicate predicate = QVTb_Factory.createPredicate(); |
| if (predicates != null) |
| predicates.add(predicate); |
| return predicate; |
| } |
| |
| protected TestDomain createTestDomain(List<? super TestDomain> contents, String name, TypedModel typedModel) { |
| TestDomain domain = TestQVTBaseFactory.eINSTANCE.createTestDomain(); |
| domain.setName(name); |
| if (typedModel != null) |
| domain.setTypedModel(typedModel); |
| if (contents != null) |
| contents.add(domain); |
| domain.setIsCheckable(true); |
| domain.setIsEnforceable(true); |
| return domain; |
| } |
| |
| protected TestExpression createTestExpression() { |
| TestExpression expression = TestQVTBaseFactory.eINSTANCE.createTestExpression(); |
| expression.setType(getStringType()); |
| return expression; |
| } |
| |
| protected TestPattern createTestPattern(List<? super TestPattern> contents) { |
| TestPattern pattern = TestQVTBaseFactory.eINSTANCE.createTestPattern(); |
| if (contents != null) |
| contents.add(pattern); |
| return pattern; |
| } |
| |
| protected TestRule createTestRule(List<? super TestRule> contents, String name) { |
| TestRule rule = TestQVTBaseFactory.eINSTANCE.createTestRule(); |
| rule.setName(name); |
| if (contents != null) |
| contents.add(rule); |
| return rule; |
| } |
| |
| protected TestTransformation createTestTransformation(List<? super TestTransformation> contents, String name) { |
| TestTransformation transformation = TestQVTBaseFactory.eINSTANCE.createTestTransformation(); |
| transformation.setName(name); |
| if (contents != null) |
| contents.add(transformation); |
| return transformation; |
| } |
| |
| protected Transformation createTransformation(Resource resource, String name) { |
| Transformation transformation = QVTb_Factory.createTransformation(); |
| transformation.setName(name); |
| if (resource != null) |
| resource.getContents().add(transformation); |
| return transformation; |
| } |
| |
| protected TypedModel createTypedModel(Transformation transformation, String name, EPackage... usedPackages) { |
| TypedModel typedModel = QVTb_Factory.createTypedModel(); |
| typedModel.setName(name); |
| if (usedPackages != null) |
| for (EPackage usedPackage : usedPackages) |
| typedModel.getUsedPackage().add(usedPackage); |
| if (transformation != null) |
| transformation.getModelParameter().add(typedModel); |
| return typedModel; |
| } |
| |
| protected String getQualifiedNameOf(Object object) { |
| return TestFormattingHelper.INSTANCE.formatQualifiedName(object); |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| resourceSet = new ResourceSetImpl(); |
| resourceSet.getResourceFactoryRegistry().getContentTypeToFactoryMap().put(QVTBasePackage.eCONTENT_TYPE, new XMIResourceFactoryImpl()); |
| resource = resourceSet.createResource(URI.createURI("TestURI"), QVTBasePackage.eCONTENT_TYPE); |
| } |
| |
| protected void validationTest(ProblemLog expectedProblems) { |
| AbstractProblemHandler actualProblems = new ProblemLog(); |
| DiagnosticChain diagnosticChain = new ProblemHandlerDiagnosticChain(actualProblems); |
| Diagnostician diagnostician = createDiagnostician(); |
| Map<Object, Object> context = new HashMap<Object, Object>(); |
| context.put(EValidator.SubstitutionLabelProvider.class, TestFormattingHelper.INSTANCE); |
| context.put(EValidator.class, diagnostician); |
| for (EObject eObject : resource.getContents()) { |
| diagnostician.validate(eObject, diagnosticChain, context); |
| } |
| if (expectedProblems != null) { |
| // expectedProblems.setParser(environment.getParser()); |
| assertEquals(expectedProblems, (ProblemLog)actualProblems); |
| } |
| else { |
| int errorCount = ((StringProblemHandler) actualProblems).getProblemCount(); |
| if (errorCount > 0) { |
| StringBuffer s = new StringBuffer(); |
| s.append(errorCount + " validation errors\n"); |
| s.append(((StringProblemHandler) actualProblems).getProblemString()); |
| if (copyErrorToConsole) |
| System.out.println(s.toString()); |
| s.setLength(s.length()-1); |
| fail(s.toString()); |
| } |
| } |
| } |
| } |