diff options
| author | Yvan Lussaud | 2015-03-25 14:48:32 +0000 |
|---|---|---|
| committer | Yvan Lussaud | 2015-03-25 14:48:32 +0000 |
| commit | a58681c6d8433d2418fd03513dcd467f00961310 (patch) | |
| tree | 4c73b7242abb10829d64f171fee4a9e8e1362d14 | |
| parent | 607c4bdec7bf1a829d336d34af3ee50d19725b5b (diff) | |
| download | org.eclipse.acceleo-a58681c6d8433d2418fd03513dcd467f00961310.tar.gz org.eclipse.acceleo-a58681c6d8433d2418fd03513dcd467f00961310.tar.xz org.eclipse.acceleo-a58681c6d8433d2418fd03513dcd467f00961310.zip | |
[462488] Validation complains about EStringToStringMapEntry.eContainer()
Added IQueryEnvironment.registerCustomClassMapping()
Bug: 462488
Change-Id: I0e1498b6d5752d8aedba297e8c1a99d8e84da741
49 files changed, 2619 insertions, 2072 deletions
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/parser/AstCompletor.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/parser/AstCompletor.java index 07d61ceca..61d047fcd 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/parser/AstCompletor.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/parser/AstCompletor.java @@ -165,8 +165,8 @@ public class AstCompletor extends AstSwitch<List<ICompletionProposal>> { final Set<IType> collectionTypes = new LinkedHashSet<IType>(); for (IType type : validationResult.getPossibleTypes(object.getTarget())) { - collectionTypes.add(new SequenceType(type)); - collectionTypes.add(new SetType(type)); + collectionTypes.add(new SequenceType(services.getQueryEnvironment(), type)); + collectionTypes.add(new SetType(services.getQueryEnvironment(), type)); } result.addAll(services.getServiceProposals(collectionTypes, false)); diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/parser/AstValidator.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/parser/AstValidator.java index de3524e5d..be2a0ba94 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/parser/AstValidator.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/parser/AstValidator.java @@ -196,9 +196,9 @@ public class AstValidator extends AstSwitch<Set<IType>> { for (IType type : doSwitch(object.getElementType())) { if (object.getValue() == List.class) { - possibleTypes.add(new SequenceType(type)); + possibleTypes.add(new SequenceType(services.getQueryEnvironment(), type)); } else if (object.getValue() == Set.class) { - possibleTypes.add(new SetType(type)); + possibleTypes.add(new SetType(services.getQueryEnvironment(), type)); } else { throw new UnsupportedOperationException(SHOULD_NEVER_HAPPEN); } @@ -215,7 +215,8 @@ public class AstValidator extends AstSwitch<Set<IType>> { @Override public Set<IType> caseEnumLiteral(EnumLiteral object) { final Set<IType> possibleTypes = new LinkedHashSet<IType>(); - possibleTypes.add(new EClassifierType(object.getLiteral().getEEnum())); + possibleTypes + .add(new EClassifierType(services.getQueryEnvironment(), object.getLiteral().getEEnum())); return checkWarningsAndErrors(object, possibleTypes); } @@ -282,7 +283,8 @@ public class AstValidator extends AstSwitch<Set<IType>> { .getName()); for (IType lambdaEvaluatorPossibleType : lambdaEvaluatorPossibleTypes) { for (IType lambdaExpressionType : lambdaExpressionPossibleTypes) { - lambdaExpressionTypes.add(new LambdaType(lambdaEvaluatorPossibleType, lambdaExpressionType)); + lambdaExpressionTypes.add(new LambdaType(services.getQueryEnvironment(), + lambdaEvaluatorPossibleType, lambdaExpressionType)); } } variableTypesStack.pop(); @@ -350,7 +352,8 @@ public class AstValidator extends AstSwitch<Set<IType>> { if (object.getValue() instanceof EClassifier) { possibleTypes = new LinkedHashSet<IType>(); - possibleTypes.add(new EClassifierLiteralType((EClassifier)object.getValue())); + possibleTypes.add(new EClassifierLiteralType(services.getQueryEnvironment(), (EClassifier)object + .getValue())); } else if (object.getValue() instanceof Class<?>) { possibleTypes = services.getIType((Class<?>)object.getValue()); } else { @@ -411,7 +414,7 @@ public class AstValidator extends AstSwitch<Set<IType>> { public Set<IType> caseNullLiteral(NullLiteral object) { final Set<IType> possibleTypes = new LinkedHashSet<IType>(); - possibleTypes.add(new ClassType(null)); + possibleTypes.add(new ClassType(services.getQueryEnvironment(), null)); return checkWarningsAndErrors(object, possibleTypes); } @@ -427,7 +430,7 @@ public class AstValidator extends AstSwitch<Set<IType>> { for (Expression expression : object.getValues()) { for (IType type : doSwitch(expression)) { - possibleTypes.add(new SetType(type)); + possibleTypes.add(new SetType(services.getQueryEnvironment(), type)); } } @@ -445,7 +448,7 @@ public class AstValidator extends AstSwitch<Set<IType>> { for (Expression expression : object.getValues()) { for (IType type : doSwitch(expression)) { - possibleTypes.add(new SequenceType(type)); + possibleTypes.add(new SequenceType(services.getQueryEnvironment(), type)); } } diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IEPackageProvider.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IEPackageProvider.java new file mode 100644 index 000000000..0320472b0 --- /dev/null +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IEPackageProvider.java @@ -0,0 +1,243 @@ +/******************************************************************************* + * Copyright (c) 2015 Obeo. + * 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: + * Obeo - initial API and implementation + *******************************************************************************/ +package org.eclipse.acceleo.query.runtime; + +import java.util.List; +import java.util.Set; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EClassifier; +import org.eclipse.emf.ecore.EEnumLiteral; +import org.eclipse.emf.ecore.EOperation; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.EParameter; +import org.eclipse.emf.ecore.EStructuralFeature; + +/** + * Provides {@link EPackage} in the {@link IReadOnlyQueryEnvironment}. + * + * @author <a href="mailto:yvan.lussaud@obeo.fr">Yvan Lussaud</a> + */ +public interface IEPackageProvider { + + /** + * Returns the package registered with the specified nsPrefix. Returns null if no such package is + * registered. + * + * @param nsPrefix + * the nsPrefix of the requested package. + * @return the package registered with the specified nsPrefix. + */ + EPackage getEPackage(String nsPrefix); + + /** + * Lookups the {@link EOperation} with the given receiving {@link EClass}, given + * {@link EOperation#getName() name} and {@link EOperation#getEParameters() parameters} type. + * + * @param receiverEClass + * the receiver {@link EClass} + * @param eOperationName + * the {@link EOperation#getName() EOperation's name} + * @param parameterTypes + * the {@link EOperation#getEParameters() parameters} type + * @return the {@link EOperation} with the given receiving {@link EClass}, given + * {@link EOperation#getName() name} and {@link EOperation#getEParameters() parameters} type + */ + EOperation lookupEOperation(EClass receiverEClass, String eOperationName, List<EParameter> parameterTypes); + + /** + * Gets the {@link Set} of {@link EOperation} for the given {@link Set} of receiver {@link EClass}. + * + * @param receiverTypes + * the {@link Set} of receiver {@link EClass} + * @return the {@link Set} of {@link EOperation} for the given {@link Set} of receiver {@link EClass} + */ + Set<EOperation> getEOperations(Set<EClass> receiverTypes); + + /** + * the classifier with the specified name in the package registered with the specified nsPrefix. + * + * @param nsPrefix + * the nsPrefix of the searched classifier's package + * @param classifierName + * the name of the searched classifier + * @return the classifier with the specified name in the package registered with the specified nsPrefix. + */ + EClassifier getType(String nsPrefix, String classifierName); + + /** + * Returns an {@link EClassifier} instance when a unique one is found in all the registered packages. If + * several are found, returns <code>null</code> and log a warning. + * + * @param classifierName + * the name of the search classifier. + * @return the requested classifier unless several classifiers have the same name in different packages. + */ + EClassifier getType(String classifierName); + + /** + * Returns the {@link EEnumLiteral} with the specified name in the specified enum. + * + * @param nsPrefix + * the nsPrefix of the package where to search the {@link EEnumLiteral} + * @param enumName + * the name of the {@link org.eclipse.emf.ecore.EEnum EEnum} containing the literal. + * @param literalName + * the name of the searched {@link EEnumLiteral}. + * @return the specified {@link EEnumLiteral} + */ + EEnumLiteral getEnumLiteral(String nsPrefix, String enumName, String literalName); + + /** + * Returns the {@link EEnumLiteral} with the specified name in the specified enum if it exists in one of + * the registered package. Returns <code>null</code> otherwise. + * + * @param enumName + * the name of the {@link org.eclipse.emf.ecore.EEnum EEnum} containing the literal. + * @param literalName + * the name of the searched {@link EEnumLiteral}. + * @return the specified {@link EEnumLiteral} + */ + EEnumLiteral getEnumLiteral(String enumName, String literalName); + + /** + * Gets the {@link EClassifier} represented by the given {@link Class}. + * + * @param cls + * the {@link Class} + * @return the {@link EClassifier} represented by the given {@link Class} if any, <code>null</code> + * otherwise + */ + Set<EClassifier> getEClass(Class<?> cls); + + /** + * Gets the {@link Class} of instance of the given {@link EClassifier}. + * + * @param eCls + * the {@link EClassifier} + * @return the {@link Class} of instance of the given {@link EClassifier} if any, <code>null</code> + * otherwise + */ + Class<?> getClass(EClassifier eCls); + + /** + * Gets the {@link EStructuralFeature} from the given {@link Set} of {@link EClass}. + * + * @param receiverEClasses + * the {@link Set} of {@link EClass}. + * @return the {@link EStructuralFeature} from the given {@link Set} of {@link EClass} + */ + Set<EStructuralFeature> getEStructuralFeatures(Set<EClass> receiverEClasses); + + /** + * Gets the {@link Set} of {@link IQueryEnvironment#registerEPackage(EPackage) registered} + * {@link EClassifier}. + * + * @return the {@link Set} of {@link IQueryEnvironment#registerEPackage(EPackage) registered} + * {@link EClassifier} + */ + Set<EClassifier> getEClassifiers(); + + /** + * Gets the {@link Set} of {@link IQueryEnvironment#registerEPackage(EPackage) registered} + * {@link EEnumLiteral}. + * + * @return the {@link Set} of {@link IQueryEnvironment#registerEPackage(EPackage) registered} + * {@link EEnumLiteral} + */ + Set<EEnumLiteral> getEEnumLiterals(); + + /** + * Gets the {@link Set} of {@link EClass} that can directly contain in the given {@link EClass}. + * + * @param eCls + * the {@link EClass} + * @return the {@link Set} of {@link EClass} that can directly contain in the given {@link EClass} + */ + Set<EClass> getContainingEClasses(EClass eCls); + + /** + * Gets the {@link Set} of {@link EClass} that can directly and indirectly contain in the given + * {@link EClass}. + * + * @param eCls + * the {@link EClass} + * @return the {@link Set} of {@link EClass} that can directly and indirectly contain in the given + * {@link EClass} + */ + Set<EClass> getAllContainingEClasses(EClass eCls); + + /** + * Gets all sub types for the given {@link EClass}. + * + * @param eCls + * the {@link EClass} + * @return all sub types for the given {@link EClass} + */ + Set<EClass> getAllSubTypes(EClass eCls); + + /** + * Gets the {@link Set} of {@link EClass} that can be directly contained in the given {@link EClass}. + * + * @param eCls + * the {@link EClass} + * @return the {@link Set} of {@link EClass} that can be directly contained in the given {@link EClass} + */ + Set<EClass> getContainedEClasses(EClass eCls); + + /** + * Gets the {@link Set} of {@link EClass} that can be directly and indirectly contained in the given + * {@link EClass}. + * + * @param eCls + * the {@link EClass} + * @return the {@link Set} of {@link EClass} that can be directly and indirectly contained in the given + * {@link EClass} + */ + Set<EClass> getAllContainedEClasses(EClass eCls); + + /** + * Gets the {@link Set} of {@link EClass} that can directly reference the given {@link EClass}. + * + * @param eCls + * the {@link EClass} + * @return the {@link Set} of {@link EClass} that can directly reference in the given {@link EClass} + */ + Set<EClass> getInverseEClasses(EClass eCls); + + /** + * Gets the {@link Set} of {@link EClass} that can be following siblings of the given {@link EClass}. + * + * @param eCls + * the {@link EClass} + * @return the {@link Set} of {@link EClass} that can be following siblings of the given {@link EClass} + */ + Set<EClass> getFollowingSiblingsEClasses(EClass eCls); + + /** + * Gets the {@link Set} of {@link EClass} that can be preceding siblings of the given {@link EClass}. + * + * @param eCls + * the {@link EClass} + * @return the {@link Set} of {@link EClass} that can be preceding siblings of the given {@link EClass} + */ + Set<EClass> getPrecedingSiblingsEClasses(EClass eCls); + + /** + * Gets the {@link Set} of {@link EClassifier} that can be siblings of the given {@link EClass}. + * + * @param eCls + * the {@link EClass} + * @return the {@link Set} of {@link EClassifier} that can be siblings of the given {@link EClass} + */ + Set<EClass> getSiblingsEClasses(EClass eCls); + +} diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ILookupEngine.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ILookupEngine.java new file mode 100644 index 000000000..e08b9afea --- /dev/null +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ILookupEngine.java @@ -0,0 +1,83 @@ +/******************************************************************************* + * Copyright (c) 2015 Obeo. + * 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: + * Obeo - initial API and implementation + *******************************************************************************/ +package org.eclipse.acceleo.query.runtime; + +import java.lang.reflect.Method; +import java.util.Set; + +/** + * Provides {@link IService} in the {@link IReadOnlyQueryEnvironment}. + * + * @author <a href="mailto:yvan.lussaud@obeo.fr">Yvan Lussaud</a> + */ +public interface ILookupEngine { + + /** + * Message used when a service cannot be instanciated. + */ + String INSTANTIATION_PROBLEM_MSG = "Couldn't instantiate class "; + + /** + * Returns the {@link CrossReferencer} that this engine uses. + * + * @return The {@link CrossReferencer} that this engine uses. + */ + CrossReferenceProvider getCrossReferencer(); + + /** + * Returns the service that has the specified name and that best matches the specified argument types if + * any is found. Services are ordered according to their parameter types. A type <em>T1</em> is lower than + * a type <em>T2</em> if <em>T1</em>is a sub-class of <em>T2</em>. A method <em>M1</em> is lower than a + * method <em>M2</em> if all the types of the former are lower than the type of the later at the same + * index. + * + * @param name + * the name of the service to retrieve. + * @param argumentTypes + * the types of the arguments to best match. + * @return the best service's match of the registered services if any. + */ + IService lookup(String name, Class<?>[] argumentTypes); + + /** + * Tells if the given method is the one that indicates we have to set the cross referencer to the service + * instance. + * + * @param method + * The method we want to know if it the one that indicates we have to set the cross referencer + * to the service instance. + * @return true if the given method is the one that indicates we have to set the cross referencer to the + * service instance. False otherwise. + */ + boolean isCrossReferencerMethod(Method method); + + /** + * Gets the {@link Set} of known {@link IService} with a compatible receiver type. + * + * @param receiverTypes + * the receiver types + * @return the {@link Set} of known {@link IService} with a compatible receiver type + */ + Set<IService> getServices(Set<Class<?>> receiverTypes); + + /** + * Tells if a given {@link Method} is considered as a {@link IService#getServiceMethod() service} to + * provide when querying. + * + * @param method + * the method we want to know if it must be considered as a service to provide when querying. + * @return <code>true</code> if a given {@link Method} is considered as a + * {@link IService#getServiceMethod() service} to provide when querying, <code>false</code> + * otherwise + */ + boolean isServiceMethod(Method method); + +} diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironment.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironment.java index 98535e9e5..5aa7afc2f 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironment.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironment.java @@ -20,10 +20,7 @@ *******************************************************************************/ package org.eclipse.acceleo.query.runtime; -import java.util.logging.Logger; - -import org.eclipse.acceleo.query.runtime.impl.EPackageProvider; -import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine; +import org.eclipse.emf.ecore.EClassifier; import org.eclipse.emf.ecore.EPackage; /** @@ -31,7 +28,7 @@ import org.eclipse.emf.ecore.EPackage; * * @author <a href="mailto:pierre.guilet@obeo.fr">Pierre Guilet</a> */ -public interface IQueryEnvironment { +public interface IQueryEnvironment extends IReadOnlyQueryEnvironment { /** * Register a set of services. The specified {@link Class} must have a default constructor with no @@ -67,24 +64,13 @@ public interface IQueryEnvironment { void removeEPackage(String nsPrefix); /** - * Return the engine providing query services. - * - * @return the engine providing query services. - */ - BasicLookupEngine getLookupEngine(); - - /** - * Return the EPackageProvider providing access to registered ecore packages. - * - * @return the EPackageProvider providing access to registered ecore packages. - */ - EPackageProvider getEPackageProvider(); - - /** - * Returns the logger used to log messages in this evaluation environment. + * Registers a custom mapping from an {@link EClassifier} to its {@link Class}. * - * @return the logger used to log messages in this evaluation environment. + * @param eClassifier + * the {@link EClassifier} + * @param cls + * the {@link Class} */ - Logger getLogger(); + void registerCustomClassMapping(EClassifier eClassifier, Class<?> cls); } diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IReadOnlyQueryEnvironment.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IReadOnlyQueryEnvironment.java new file mode 100644 index 000000000..7e8f9efe6 --- /dev/null +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IReadOnlyQueryEnvironment.java @@ -0,0 +1,43 @@ +/******************************************************************************* + * Copyright (c) 2015 Obeo. + * 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: + * Obeo - initial API and implementation + *******************************************************************************/ +package org.eclipse.acceleo.query.runtime; + +import java.util.logging.Logger; + +/** + * An IQueryEnvironment contains all informations needed to execute query. + * + * @author <a href="mailto:yvan.lussaud@obeo.fr">Yvan Lussaud</a> + */ +public interface IReadOnlyQueryEnvironment { + + /** + * Return the {@link ILookupEngine} query {@link IService}. + * + * @return the {@link ILookupEngine} query {@link IService} + */ + ILookupEngine getLookupEngine(); + + /** + * Return the IEPackageProvider providing access to registered ecore packages. + * + * @return the EPackageProvider providing access to registered ecore packages. + */ + IEPackageProvider getEPackageProvider(); + + /** + * Returns the logger used to log messages in this evaluation environment. + * + * @return the logger used to log messages in this evaluation environment. + */ + Logger getLogger(); + +} diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IService.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IService.java index fbbdf0fd3..1a59d2c28 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IService.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IService.java @@ -15,7 +15,6 @@ import java.util.List; import java.util.Map; import java.util.Set; -import org.eclipse.acceleo.query.runtime.impl.EPackageProvider; import org.eclipse.acceleo.query.runtime.impl.ValidationServices; import org.eclipse.acceleo.query.validation.type.IType; @@ -44,13 +43,14 @@ public interface IService { * * @param services * the {@link ValidationServices} - * @param provider - * the {@link EPackageProvider} + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param argTypes * arguments {@link IType} * @return the {@link IType} of elements returned by the service */ - Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes); + Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes); /** * Validates all couple of arguments {@link IType} and the {@link IType} of elements returned by the @@ -58,14 +58,14 @@ public interface IService { * * @param services * the {@link ValidationServices} - * @param provider - * the {@link EPackageProvider} + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param allTypes * all couple of arguments {@link IType} and the {@link IType} of elements returned by the * service * @return validated {@link IType} */ - Set<IType> validateAllType(ValidationServices services, EPackageProvider provider, + Set<IType> validateAllType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, Map<List<IType>, Set<IType>> allTypes); } diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IServiceProvider.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IServiceProvider.java index 86b9f48ca..7ef646c2a 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IServiceProvider.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IServiceProvider.java @@ -12,8 +12,6 @@ package org.eclipse.acceleo.query.runtime; import java.util.List; -import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine; - /** * Interface that can be implemented by service {@link Class} to provides its own {@link IService}. * @@ -24,12 +22,13 @@ public interface IServiceProvider { /** * Gets services offered by this class. * - * @param lookup - * the {@link BasicLookupEngine} + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @return services offered by this class * @throws InvalidAcceleoPackageException * if the specified class doesn't follow the acceleo package rules. */ - List<IService> getServices(BasicLookupEngine lookup) throws InvalidAcceleoPackageException; + List<IService> getServices(IReadOnlyQueryEnvironment queryEnvironment) + throws InvalidAcceleoPackageException; } diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractLanguageServices.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractLanguageServices.java index 0211cd084..fef751928 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractLanguageServices.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractLanguageServices.java @@ -26,8 +26,7 @@ import java.util.List; import java.util.logging.Logger; import org.eclipse.acceleo.query.runtime.AcceleoQueryValidationException; -import org.eclipse.acceleo.query.runtime.IQueryEnvironment; -import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; import org.eclipse.acceleo.query.validation.type.EClassifierLiteralType; import org.eclipse.acceleo.query.validation.type.EClassifierType; import org.eclipse.acceleo.query.validation.type.IJavaType; @@ -72,14 +71,9 @@ public abstract class AbstractLanguageServices { protected static final String UNKNOWN_FEATURE = "Feature %s not found in EClass %s"; /** - * Lookup engine used to retrieve services. + * The {@link IReadOnlyQueryEnvironment}. */ - protected final BasicLookupEngine lookupEngine; - - /** - * {@link org.eclipse.emf.ecore.EPackage} instances that are available during evaluation. - */ - protected EPackageProvider ePackageProvider; + protected final IReadOnlyQueryEnvironment queryEnvironment; /** * Logger used to emit error and warning messages. @@ -92,18 +86,17 @@ public abstract class AbstractLanguageServices { protected final boolean doLog; /** - * Creates a new service instance given a {@link IQueryEnvironment} and logging flag. + * Creates a new service instance given a {@link IReadOnlyQueryEnvironment} and logging flag. * - * @param queryEnv - * the {@link IQueryEnvironment} to use + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} to use * @param doLog * when <code>true</code> the resulting instance will log error and warning messages. */ - public AbstractLanguageServices(IQueryEnvironment queryEnv, boolean doLog) { - this.lookupEngine = queryEnv.getLookupEngine(); - this.ePackageProvider = queryEnv.getEPackageProvider(); + public AbstractLanguageServices(IReadOnlyQueryEnvironment queryEnvironment, boolean doLog) { + this.queryEnvironment = queryEnvironment; this.doLog = doLog; - logger = queryEnv.getLogger(); + logger = queryEnvironment.getLogger(); } public Logger getLogger() { @@ -156,7 +149,7 @@ public abstract class AbstractLanguageServices { if (iType instanceof EClassifierLiteralType) { result = EClass.class; } else if (iType instanceof EClassifierType) { - result = this.ePackageProvider.getClass(((EClassifierType)iType).getType()); + result = queryEnvironment.getEPackageProvider().getClass(((EClassifierType)iType).getType()); } else if (iType instanceof IJavaType) { result = ((IJavaType)iType).getType(); } else { @@ -176,4 +169,13 @@ public abstract class AbstractLanguageServices { return result; } + /** + * Gets the {@link IReadOnlyQueryEnvironment}. + * + * @return the queryEnvironment the {@link IReadOnlyQueryEnvironment} + */ + public IReadOnlyQueryEnvironment getQueryEnvironment() { + return queryEnvironment; + } + } diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractService.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractService.java index 188f6c73a..0f7832a28 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractService.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractService.java @@ -17,6 +17,7 @@ import java.util.Map; import java.util.Map.Entry; import java.util.Set; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; import org.eclipse.acceleo.query.runtime.IService; import org.eclipse.acceleo.query.validation.type.IType; @@ -28,7 +29,8 @@ import org.eclipse.acceleo.query.validation.type.IType; public abstract class AbstractService implements IService { @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); Type returnType = getServiceMethod().getGenericReturnType(); @@ -37,15 +39,9 @@ public abstract class AbstractService implements IService { return result; } - /** - * {@inheritDoc} - * - * @see org.eclipse.acceleo.query.runtime.IService#validateAllType(org.eclipse.acceleo.query.runtime.impl.ValidationServices, - * org.eclipse.acceleo.query.runtime.impl.EPackageProvider, java.util.Map) - */ @Override - public Set<IType> validateAllType(ValidationServices services, EPackageProvider provider, - Map<List<IType>, Set<IType>> allTypes) { + public Set<IType> validateAllType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, Map<List<IType>, Set<IType>> allTypes) { final Set<IType> result = new LinkedHashSet<IType>(); for (Entry<List<IType>, Set<IType>> entry : allTypes.entrySet()) { diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractServiceProvider.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractServiceProvider.java index 6268d6d4b..4fb97adfb 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractServiceProvider.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractServiceProvider.java @@ -8,16 +8,6 @@ * Contributors: * Obeo - initial API and implementation *******************************************************************************/ -/******************************************************************************* - * Copyright (c) 2015 Obeo. - * 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: - * Obeo - initial API and implementation - *******************************************************************************/ package org.eclipse.acceleo.query.runtime.impl; import java.lang.reflect.InvocationTargetException; @@ -25,10 +15,11 @@ import java.lang.reflect.Method; import java.util.ArrayList; import java.util.List; +import org.eclipse.acceleo.query.runtime.ILookupEngine; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; import org.eclipse.acceleo.query.runtime.IService; import org.eclipse.acceleo.query.runtime.IServiceProvider; import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException; -import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine; /** * {@link IServiceProvider} scanning its own public methods to create {@link IService}. @@ -42,21 +33,17 @@ public abstract class AbstractServiceProvider implements IServiceProvider { */ private List<IService> services; - /** - * {@inheritDoc} - * - * @see org.eclipse.acceleo.query.runtime.IServiceProvider#getServices() - */ @Override - public List<IService> getServices(BasicLookupEngine lookup) throws InvalidAcceleoPackageException { + public List<IService> getServices(IReadOnlyQueryEnvironment queryEnvironment) + throws InvalidAcceleoPackageException { try { if (services == null) { services = new ArrayList<IService>(); final Method[] methods = this.getClass().getMethods(); for (Method method : methods) { - if (lookup.isCrossReferencerMethod(method)) { - method.invoke(this, lookup.getCrossReferencer()); - } else if (lookup.registerMethod(method)) { + if (queryEnvironment.getLookupEngine().isCrossReferencerMethod(method)) { + method.invoke(this, queryEnvironment.getLookupEngine().getCrossReferencer()); + } else if (queryEnvironment.getLookupEngine().isServiceMethod(method)) { final IService service = getService(method); if (service != null) { services.add(service); @@ -65,13 +52,13 @@ public abstract class AbstractServiceProvider implements IServiceProvider { } } } catch (IllegalAccessException e) { - throw new InvalidAcceleoPackageException(BasicLookupEngine.INSTANTIATION_PROBLEM_MSG + throw new InvalidAcceleoPackageException(ILookupEngine.INSTANTIATION_PROBLEM_MSG + getClass().getCanonicalName(), e); } catch (IllegalArgumentException e) { - throw new InvalidAcceleoPackageException(BasicLookupEngine.INSTANTIATION_PROBLEM_MSG + throw new InvalidAcceleoPackageException(ILookupEngine.INSTANTIATION_PROBLEM_MSG + getClass().getCanonicalName(), e); } catch (InvocationTargetException e) { - throw new InvalidAcceleoPackageException(BasicLookupEngine.INSTANTIATION_PROBLEM_MSG + throw new InvalidAcceleoPackageException(ILookupEngine.INSTANTIATION_PROBLEM_MSG + getClass().getCanonicalName(), e); } diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/CompletionServices.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/CompletionServices.java index b514d7d48..6b94d806f 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/CompletionServices.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/CompletionServices.java @@ -88,7 +88,7 @@ public class CompletionServices extends ValidationServices { classes.add(getClass(type)); } - for (IService service : lookupEngine.getServices(classes)) { + for (IService service : queryEnvironment.getLookupEngine().getServices(classes)) { if (keepOperators || !AstBuilderListener.OPERATOR_SERVICE_NAMES.contains(service.getServiceMethod() .getName())) { @@ -115,7 +115,7 @@ public class CompletionServices extends ValidationServices { eClasses.add((EClass)type.getType()); } } - for (EOperation eOperation : ePackageProvider.getEOperations(eClasses)) { + for (EOperation eOperation : queryEnvironment.getEPackageProvider().getEOperations(eClasses)) { result.add(new EOperationCompletionProposal(eOperation)); } @@ -139,7 +139,8 @@ public class CompletionServices extends ValidationServices { } } - for (EStructuralFeature feature : ePackageProvider.getEStructuralFeatures(eClasses)) { + for (EStructuralFeature feature : queryEnvironment.getEPackageProvider().getEStructuralFeatures( + eClasses)) { result.add(new EFeatureCompletionProposal(feature)); } @@ -154,7 +155,7 @@ public class CompletionServices extends ValidationServices { public List<EClassifierCompletionProposal> getEClassifierProposals() { final List<EClassifierCompletionProposal> result = new ArrayList<EClassifierCompletionProposal>(); - for (EClassifier eClassifier : ePackageProvider.getEClassifiers()) { + for (EClassifier eClassifier : queryEnvironment.getEPackageProvider().getEClassifiers()) { result.add(new EClassifierCompletionProposal(eClassifier)); } @@ -171,7 +172,7 @@ public class CompletionServices extends ValidationServices { public List<EClassifierCompletionProposal> getEClassifierProposals(String nsPrefix) { final List<EClassifierCompletionProposal> result = new ArrayList<EClassifierCompletionProposal>(); - final EPackage ePkg = ePackageProvider.getEPackage(nsPrefix); + final EPackage ePkg = queryEnvironment.getEPackageProvider().getEPackage(nsPrefix); if (ePkg != null) { for (EClassifier eClassifier : ePkg.getEClassifiers()) { result.add(new EClassifierCompletionProposal(eClassifier)); @@ -189,7 +190,7 @@ public class CompletionServices extends ValidationServices { public List<EEnumLiteralCompletionProposal> getEEnumLiteralProposals() { final List<EEnumLiteralCompletionProposal> result = new ArrayList<EEnumLiteralCompletionProposal>(); - for (EEnumLiteral literal : ePackageProvider.getEEnumLiterals()) { + for (EEnumLiteral literal : queryEnvironment.getEPackageProvider().getEEnumLiterals()) { result.add(new EEnumLiteralCompletionProposal(literal)); } @@ -206,7 +207,7 @@ public class CompletionServices extends ValidationServices { public List<EEnumLiteralCompletionProposal> getEEnumLiteralProposals(String nsPrefix) { final List<EEnumLiteralCompletionProposal> result = new ArrayList<EEnumLiteralCompletionProposal>(); - final EPackage ePkg = ePackageProvider.getEPackage(nsPrefix); + final EPackage ePkg = queryEnvironment.getEPackageProvider().getEPackage(nsPrefix); if (ePkg != null) { for (EClassifier eClassifier : ePkg.getEClassifiers()) { if (eClassifier instanceof EEnum) { @@ -232,7 +233,7 @@ public class CompletionServices extends ValidationServices { public List<EEnumLiteralCompletionProposal> getEEnumLiteralProposals(String nsPrefix, String eEnumName) { final List<EEnumLiteralCompletionProposal> result = new ArrayList<EEnumLiteralCompletionProposal>(); - final EPackage ePkg = ePackageProvider.getEPackage(nsPrefix); + final EPackage ePkg = queryEnvironment.getEPackageProvider().getEPackage(nsPrefix); if (ePkg != null) { EClassifier eClassifier = ePkg.getEClassifier(eEnumName); if (eClassifier instanceof EEnum) { diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/EPackageProvider.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/EPackageProvider.java index e36bde5ca..c483eca77 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/EPackageProvider.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/EPackageProvider.java @@ -20,6 +20,7 @@ import java.util.Set; import java.util.logging.Level; import java.util.logging.Logger; +import org.eclipse.acceleo.query.runtime.IEPackageProvider; import org.eclipse.emf.ecore.EAttribute; import org.eclipse.emf.ecore.EClass; import org.eclipse.emf.ecore.EClassifier; @@ -38,7 +39,7 @@ import org.eclipse.emf.ecore.EcorePackage; * * @author <a href="mailto:romain.guider@obeo.fr">Romain Guider</a> */ -public class EPackageProvider { +public class EPackageProvider implements IEPackageProvider { /** * Map nsPrefix to their corresponding package. @@ -51,6 +52,11 @@ public class EPackageProvider { private final Map<Class<?>, Set<EClassifier>> class2classifiers = new HashMap<Class<?>, Set<EClassifier>>(); /** + * {@link EClassifier} to {@link Class} mapping. + */ + private final Map<EClassifier, Class<?>> classifier2class = new HashMap<EClassifier, Class<?>>(); + + /** * Maps of multi-EOperations : maps the arity to maps that maps {@link EOperation#getName() EOperation's * name} to their {@link EOperation} {@link List}. */ @@ -98,14 +104,11 @@ public class EPackageProvider { this.logger = Logger.getLogger("EPackageProvider"); } - /** - * Returns the package registered with the specified nsPrefix. Returns null if no such package is - * registered. - * - * @param nsPrefix - * the nsPrefix of the requested package. - * @return the package registered with the specified nsPrefix. + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getEPackage(java.lang.String) */ + @Override public EPackage getEPackage(String nsPrefix) { return ePackages.get(nsPrefix); } @@ -214,7 +217,7 @@ public class EPackageProvider { * the {@link EClassifier} to remove */ private void removeEClassifierClass(EClassifier eCls) { - final Class<?> instanceClass = eCls.getInstanceClass(); + final Class<?> instanceClass = getClass(eCls); final Set<EClassifier> classifiers = class2classifiers.get(instanceClass); if (classifiers != null) { if (classifiers.size() == 1) { @@ -223,6 +226,7 @@ public class EPackageProvider { classifiers.remove(eCls); } } + classifier2class.remove(eCls); } /** @@ -304,7 +308,14 @@ public class EPackageProvider { * the {@link EClassifier} to register */ private void registerEClassifierClass(EClassifier eCls) { - final Class<?> instanceClass = eCls.getInstanceClass(); + final Class<?> customClass = classifier2class.get(eCls); + final Class<?> instanceClass; + if (customClass != null) { + instanceClass = customClass; + } else { + instanceClass = eCls.getInstanceClass(); + classifier2class.put(eCls, instanceClass); + } Set<EClassifier> classifiers = class2classifiers.get(instanceClass); if (classifiers == null) { classifiers = new LinkedHashSet<EClassifier>(); @@ -328,19 +339,11 @@ public class EPackageProvider { } } - /** - * Lookups the {@link EOperation} with the given receiving {@link EClass}, given - * {@link EOperation#getName() name} and {@link EOperation#getEParameters() parameters} type. - * - * @param receiverEClass - * the receiver {@link EClass} - * @param eOperationName - * the {@link EOperation#getName() EOperation's name} - * @param parameterTypes - * the {@link EOperation#getEParameters() parameters} type - * @return the {@link EOperation} with the given receiving {@link EClass}, given - * {@link EOperation#getName() name} and {@link EOperation#getEParameters() parameters} type + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#lookupEOperation(org.eclipse.emf.ecore.EClass, java.lang.String, java.util.List) */ + @Override public EOperation lookupEOperation(EClass receiverEClass, String eOperationName, List<EParameter> parameterTypes) { final EOperation result; @@ -371,13 +374,11 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link Set} of {@link EOperation} for the given {@link Set} of receiver {@link EClass}. - * - * @param receiverTypes - * the {@link Set} of receiver {@link EClass} - * @return the {@link Set} of {@link EOperation} for the given {@link Set} of receiver {@link EClass} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getEOperations(java.util.Set) */ + @Override public Set<EOperation> getEOperations(Set<EClass> receiverTypes) { final Set<EOperation> result = new LinkedHashSet<EOperation>(); @@ -420,15 +421,11 @@ public class EPackageProvider { return result; } - /** - * the classifier with the specified name in the package registered with the specified nsPrefix. - * - * @param nsPrefix - * the nsPrefix of the searched classifier's package - * @param classifierName - * the name of the searched classifier - * @return the classifier with the specified name in the package registered with the specified nsPrefix. + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getType(java.lang.String, java.lang.String) */ + @Override public EClassifier getType(String nsPrefix, String classifierName) { EPackage ePackage = ePackages.get(nsPrefix); if (ePackage != null) { @@ -438,14 +435,11 @@ public class EPackageProvider { } } - /** - * Returns an {@link EClassifier} instance when a unique one is found in all the registered packages. If - * several are found, returns <code>null</code> and log a warning. - * - * @param classifierName - * the name of the search classifier. - * @return the requested classifier unless several classifiers have the same name in different packages. + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getType(java.lang.String) */ + @Override public EClassifier getType(String classifierName) { EClassifier result = null; for (EPackage ePackage : ePackages.values()) { @@ -467,17 +461,11 @@ public class EPackageProvider { return result; } - /** - * Returns the {@link EEnumLiteral} with the specified name in the specified enum. - * - * @param nsPrefix - * the nsPrefix of the package where to search the {@link EEnumLiteral} - * @param enumName - * the name of the {@link EEnum} containing the literal. - * @param literalName - * the name of the searched {@link EEnumLiteral}. - * @return the specified {@link EEnumLiteral} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getEnumLiteral(java.lang.String, java.lang.String, java.lang.String) */ + @Override public EEnumLiteral getEnumLiteral(String nsPrefix, String enumName, String literalName) { final EEnumLiteral result; @@ -492,16 +480,11 @@ public class EPackageProvider { return result; } - /** - * Returns the {@link EEnumLiteral} with the specified name in the specified enum if it exists in one of - * the registered package. Returns <code>null</code> otherwise. - * - * @param enumName - * the name of the {@link EEnum} containing the literal. - * @param literalName - * the name of the searched {@link EEnumLiteral}. - * @return the specified {@link EEnumLiteral} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getEnumLiteral(java.lang.String, java.lang.String) */ + @Override public EEnumLiteral getEnumLiteral(String enumName, String literalName) { EClassifier eClassifier = getType(enumName); if (eClassifier == null) { @@ -531,36 +514,56 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link EClassifier} represented by the given {@link Class}. - * - * @param cls - * the {@link Class} - * @return the {@link EClassifier} represented by the given {@link Class} if any, <code>null</code> - * otherwise + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getEClass(java.lang.Class) */ + @Override public Set<EClassifier> getEClass(Class<?> cls) { return class2classifiers.get(cls); } - /** - * Gets the {@link Class} of instance of the given {@link EClassifier}. - * - * @param eCls - * the {@link EClassifier} - * @return the {@link Class} of instance of the given {@link EClassifier} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getClass(org.eclipse.emf.ecore.EClassifier) */ + @Override public Class<?> getClass(EClassifier eCls) { - return eCls.getInstanceClass(); + return classifier2class.get(eCls); } /** - * Gets the {@link EStructuralFeature} from the given {@link Set} of {@link EClass}. + * Registers a custom mapping from an {@link EClassifier} to its {@link Class}. * - * @param receiverEClasses - * the {@link Set} of {@link EClass}. - * @return the {@link EStructuralFeature} from the given {@link Set} of {@link EClass} + * @param eClassifier + * the {@link EClassifier} + * @param cls + * the {@link Class} + */ + void registerCustomClassMapping(EClassifier eClassifier, Class<?> cls) { + // remove old mappings + final Class<?> oldClass = classifier2class.remove(eClassifier); + if (oldClass != null) { + final Set<EClassifier> eClassifiers = class2classifiers.get(oldClass); + if (eClassifiers.remove(eClassifier) && eClassifiers.isEmpty()) { + class2classifiers.remove(oldClass); + } + } + // add new mappings + classifier2class.put(eClassifier, cls); + Set<EClassifier> eClassifiers = class2classifiers.get(cls); + if (eClassifiers == null) { + eClassifiers = new LinkedHashSet<EClassifier>(); + class2classifiers.put(cls, eClassifiers); + } + eClassifiers.add(eClassifier); + } + + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getEStructuralFeatures(java.util.Set) */ + @Override public Set<EStructuralFeature> getEStructuralFeatures(Set<EClass> receiverEClasses) { Set<EStructuralFeature> result = new LinkedHashSet<EStructuralFeature>(); @@ -571,13 +574,11 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link Set} of {@link EPackageProvider#registerPackage(EPackage) registered} - * {@link EClassifier}. - * - * @return the {@link Set} of {@link EPackageProvider#registerPackage(EPackage) registered} - * {@link EClassifier} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getEClassifiers() */ + @Override public Set<EClassifier> getEClassifiers() { final Set<EClassifier> result = new LinkedHashSet<EClassifier>(); @@ -588,13 +589,11 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link Set} of {@link EPackageProvider#registerPackage(EPackage) registered} - * {@link EEnumLiteral}. - * - * @return the {@link Set} of {@link EPackageProvider#registerPackage(EPackage) registered} - * {@link EEnumLiteral} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getEEnumLiterals() */ + @Override public Set<EEnumLiteral> getEEnumLiterals() { final Set<EEnumLiteral> result = new LinkedHashSet<EEnumLiteral>(); @@ -655,13 +654,11 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link Set} of {@link EClass} that can directly contain in the given {@link EClass}. - * - * @param eCls - * the {@link EClass} - * @return the {@link Set} of {@link EClass} that can directly contain in the given {@link EClass} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getContainingEClasses(org.eclipse.emf.ecore.EClass) */ + @Override public Set<EClass> getContainingEClasses(EClass eCls) { final Set<EClass> result = new LinkedHashSet<EClass>(); @@ -672,15 +669,11 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link Set} of {@link EClass} that can directly and indirectly contain in the given - * {@link EClass}. - * - * @param eCls - * the {@link EClass} - * @return the {@link Set} of {@link EClass} that can directly and indirectly contain in the given - * {@link EClass} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getAllContainingEClasses(org.eclipse.emf.ecore.EClass) */ + @Override public Set<EClass> getAllContainingEClasses(EClass eCls) { final Set<EClass> direcltyContainingEClasses = getContainingEClasses(eCls); final Set<EClass> result = new LinkedHashSet<EClass>(direcltyContainingEClasses); @@ -745,13 +738,11 @@ public class EPackageProvider { return result; } - /** - * Gets all sub types for the given {@link EClass}. - * - * @param eCls - * the {@link EClass} - * @return all sub types for the given {@link EClass} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getAllSubTypes(org.eclipse.emf.ecore.EClass) */ + @Override public Set<EClass> getAllSubTypes(EClass eCls) { final Set<EClass> result = new LinkedHashSet<EClass>(); @@ -766,13 +757,11 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link Set} of {@link EClass} that can be directly contained in the given {@link EClass}. - * - * @param eCls - * the {@link EClass} - * @return the {@link Set} of {@link EClass} that can be directly contained in the given {@link EClass} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getContainedEClasses(org.eclipse.emf.ecore.EClass) */ + @Override public Set<EClass> getContainedEClasses(EClass eCls) { final Set<EClass> result = new LinkedHashSet<EClass>(); @@ -790,15 +779,11 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link Set} of {@link EClass} that can be directly and indirectly contained in the given - * {@link EClass}. - * - * @param eCls - * the {@link EClass} - * @return the {@link Set} of {@link EClass} that can be directly and indirectly contained in the given - * {@link EClass} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getAllContainedEClasses(org.eclipse.emf.ecore.EClass) */ + @Override public Set<EClass> getAllContainedEClasses(EClass eCls) { final Set<EClass> direcltyContainedEClasses = getContainedEClasses(eCls); final Set<EClass> result = new LinkedHashSet<EClass>(direcltyContainedEClasses); @@ -819,13 +804,11 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link Set} of {@link EClass} that can directly reference the given {@link EClass}. - * - * @param eCls - * the {@link EClass} - * @return the {@link Set} of {@link EClass} that can directly reference in the given {@link EClass} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getInverseEClasses(org.eclipse.emf.ecore.EClass) */ + @Override public Set<EClass> getInverseEClasses(EClass eCls) { final Set<EClass> result = new LinkedHashSet<EClass>(); @@ -867,13 +850,11 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link Set} of {@link EClass} that can be following siblings of the given {@link EClass}. - * - * @param eCls - * the {@link EClass} - * @return the {@link Set} of {@link EClass} that can be following siblings of the given {@link EClass} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getFollowingSiblingsEClasses(org.eclipse.emf.ecore.EClass) */ + @Override public Set<EClass> getFollowingSiblingsEClasses(EClass eCls) { final Set<EClass> result = new LinkedHashSet<EClass>(); @@ -929,13 +910,11 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link Set} of {@link EClass} that can be preceding siblings of the given {@link EClass}. - * - * @param eCls - * the {@link EClass} - * @return the {@link Set} of {@link EClass} that can be preceding siblings of the given {@link EClass} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getPrecedingSiblingsEClasses(org.eclipse.emf.ecore.EClass) */ + @Override public Set<EClass> getPrecedingSiblingsEClasses(EClass eCls) { final Set<EClass> result = new LinkedHashSet<EClass>(); @@ -984,13 +963,11 @@ public class EPackageProvider { return result; } - /** - * Gets the {@link Set} of {@link EClassifier} that can be siblings of the given {@link EClass}. - * - * @param eCls - * the {@link EClass} - * @return the {@link Set} of {@link EClassifier} that can be siblings of the given {@link EClass} + /**{@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IEPackageProvider#getSiblingsEClasses(org.eclipse.emf.ecore.EClass) */ + @Override public Set<EClass> getSiblingsEClasses(EClass eCls) { final Set<EClass> result = new LinkedHashSet<EClass>(); diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/EvaluationServices.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/EvaluationServices.java index b7a169bd4..465416653 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/EvaluationServices.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/EvaluationServices.java @@ -282,7 +282,7 @@ public class EvaluationServices extends AbstractLanguageServices { } try { Class<?>[] argumentTypes = getArgumentTypes(arguments); - IService service = this.lookupEngine.lookup(serviceName, argumentTypes); + IService service = queryEnvironment.getLookupEngine().lookup(serviceName, argumentTypes); if (service == null) { if (arguments[0] instanceof EObject) { final List<Set<EParameter>> eClassifiers = getEParameters(Arrays.copyOfRange(arguments, @@ -291,12 +291,12 @@ public class EvaluationServices extends AbstractLanguageServices { if (arguments.length > 1) { final Iterator<List<EParameter>> it = new CombineIterator<EParameter>(eClassifiers); while (eOperation == null && it.hasNext()) { - eOperation = ePackageProvider.lookupEOperation(((EObject)arguments[0]).eClass(), - serviceName, it.next()); + eOperation = queryEnvironment.getEPackageProvider().lookupEOperation( + ((EObject)arguments[0]).eClass(), serviceName, it.next()); } } else { - eOperation = ePackageProvider.lookupEOperation(((EObject)arguments[0]).eClass(), - serviceName, new ArrayList<EParameter>()); + eOperation = queryEnvironment.getEPackageProvider().lookupEOperation( + ((EObject)arguments[0]).eClass(), serviceName, new ArrayList<EParameter>()); } if (eOperation != null) { final EList<Object> eArguments = new BasicEList<Object>(); @@ -345,7 +345,8 @@ public class EvaluationServices extends AbstractLanguageServices { parameter.setEType(((EObject)object).eClass()); eParamters.add(parameter); } else if (object != null) { - for (EClassifier eClassifier : ePackageProvider.getEClass(object.getClass())) { + for (EClassifier eClassifier : queryEnvironment.getEPackageProvider().getEClass( + object.getClass())) { final EParameter parameter = EcorePackage.eINSTANCE.getEcoreFactory().createEParameter(); parameter.setEType(eClassifier); eParamters.add(parameter); diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryEnvironment.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryEnvironment.java index dfb3846d7..e2a60b9dc 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryEnvironment.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryEnvironment.java @@ -32,6 +32,7 @@ import org.eclipse.acceleo.query.services.CollectionServices; import org.eclipse.acceleo.query.services.EObjectServices; import org.eclipse.acceleo.query.services.NumberServices; import org.eclipse.acceleo.query.services.StringServices; +import org.eclipse.emf.ecore.EClassifier; import org.eclipse.emf.ecore.EPackage; /** @@ -65,7 +66,7 @@ public class QueryEnvironment implements IQueryEnvironment { */ public QueryEnvironment(CrossReferenceProvider crossReferencer) { ePackageProvider = new EPackageProvider(); - lookupEngine = new BasicLookupEngine(crossReferencer); + lookupEngine = new BasicLookupEngine(this, crossReferencer); this.initStandardServices(); this.logger = Logger.getLogger(this.getClass().getName()); } @@ -99,6 +100,17 @@ public class QueryEnvironment implements IQueryEnvironment { ePackageProvider.removePackage(nsPrefix); } + /** + * {@inheritDoc} + * + * @see org.eclipse.acceleo.query.runtime.IQueryEnvironment#registerCustomClassMapping(org.eclipse.emf.ecore.EClassifier, + * java.lang.Class) + */ + @Override + public void registerCustomClassMapping(EClassifier eClassifier, Class<?> cls) { + ePackageProvider.registerCustomClassMapping(eClassifier, cls); + } + @Override public BasicLookupEngine getLookupEngine() { return lookupEngine; diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/ValidationServices.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/ValidationServices.java index 1dd70f849..6ff083354 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/ValidationServices.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/ValidationServices.java @@ -133,7 +133,7 @@ public class ValidationServices extends AbstractLanguageServices { result.add(nothing(UNKNOWN_FEATURE, featureName, eClass.getName())); } else { if (feature.isMany()) { - result.add(new SequenceType(getFeatureBasicType(feature))); + result.add(new SequenceType(queryEnvironment, getFeatureBasicType(feature))); } else { result.add(getFeatureBasicType(feature)); } @@ -163,7 +163,7 @@ public class ValidationServices extends AbstractLanguageServices { * @return the basic type of the given {@link EStructuralFeature}. It doesn't bother with the cardinality. */ private IType getFeatureBasicType(EStructuralFeature feature) { - return new EClassifierType(feature.getEType()); + return new EClassifierType(queryEnvironment, feature.getEType()); } /** @@ -186,9 +186,9 @@ public class ValidationServices extends AbstractLanguageServices { // flatten if (featureAccessType instanceof ICollectionType) { - result = new SetType(((ICollectionType)featureAccessType).getCollectionType()); + result = new SetType(queryEnvironment, ((ICollectionType)featureAccessType).getCollectionType()); } else { - result = new SetType(featureAccessType); + result = new SetType(queryEnvironment, featureAccessType); } return result; @@ -214,9 +214,10 @@ public class ValidationServices extends AbstractLanguageServices { // flatten if (featureAccessType instanceof ICollectionType) { - result = new SequenceType(((ICollectionType)featureAccessType).getCollectionType()); + result = new SequenceType(queryEnvironment, ((ICollectionType)featureAccessType) + .getCollectionType()); } else { - result = new SequenceType(featureAccessType); + result = new SequenceType(queryEnvironment, featureAccessType); } return result; @@ -244,13 +245,13 @@ public class ValidationServices extends AbstractLanguageServices { while (it.hasNext()) { List<IType> currentArgTypes = it.next(); Class<?>[] argumentTypes = getArgumentTypes(currentArgTypes); - IService service = this.lookupEngine.lookup(serviceName, argumentTypes); + IService service = queryEnvironment.getLookupEngine().lookup(serviceName, argumentTypes); if (service == null) { if (currentArgTypes.get(0).getType() instanceof EClass) { final List<EParameter> eParameters = getEParameters(currentArgTypes); final EClass reveiverType = (EClass)eParameters.remove(0).getEType(); - final EOperation eOperation = ePackageProvider.lookupEOperation(reveiverType, - serviceName, eParameters); + final EOperation eOperation = queryEnvironment.getEPackageProvider() + .lookupEOperation(reveiverType, serviceName, eParameters); if (eOperation != null) { result.add(getEOperationType(eOperation)); } else { @@ -337,7 +338,7 @@ public class ValidationServices extends AbstractLanguageServices { * @return the return {@link IType} of a {@link IService service} */ private Set<IType> getServiceTypes(IService service, List<IType> argTypes) { - return service.getType(this, ePackageProvider, argTypes); + return service.getType(this, queryEnvironment, argTypes); } /** @@ -350,7 +351,7 @@ public class ValidationServices extends AbstractLanguageServices { * @return the validated return {@link IType} of a {@link IService service} */ private Set<IType> validateServiceAllTypes(IService service, Map<List<IType>, Set<IType>> allTypes) { - return service.validateAllType(this, ePackageProvider, allTypes); + return service.validateAllType(this, queryEnvironment, allTypes); } /** @@ -363,9 +364,9 @@ public class ValidationServices extends AbstractLanguageServices { private IType getEOperationType(EOperation eOperation) { final IType result; - final IType eClassifierType = new EClassifierType(eOperation.getEType()); + final IType eClassifierType = new EClassifierType(queryEnvironment, eOperation.getEType()); if (eOperation.isMany()) { - result = new SequenceType(eClassifierType); + result = new SequenceType(queryEnvironment, eClassifierType); } else { result = eClassifierType; } @@ -437,9 +438,10 @@ public class ValidationServices extends AbstractLanguageServices { if (!(rawResultType instanceof NothingType)) { // flatten if (rawResultType instanceof ICollectionType) { - result.add(new SequenceType(((ICollectionType)rawResultType).getCollectionType())); + result.add(new SequenceType(queryEnvironment, ((ICollectionType)rawResultType) + .getCollectionType())); } else { - result.add(new SequenceType(rawResultType)); + result.add(new SequenceType(queryEnvironment, rawResultType)); } } } @@ -481,9 +483,10 @@ public class ValidationServices extends AbstractLanguageServices { if (!(rawResultType instanceof NothingType)) { // flatten if (rawResultType instanceof ICollectionType) { - result.add(new SetType(((ICollectionType)rawResultType).getCollectionType())); + result.add(new SetType(queryEnvironment, ((ICollectionType)rawResultType) + .getCollectionType())); } else { - result.add(new SetType(rawResultType)); + result.add(new SetType(queryEnvironment, rawResultType)); } } } @@ -517,7 +520,7 @@ public class ValidationServices extends AbstractLanguageServices { for (IType receiverType : receiverTypes) { if (!(receiverType instanceof ICollectionType) && !(receiverTypes instanceof NothingType)) { // implicit set conversion. - newReceiverTypes.add(new SetType(receiverType)); + newReceiverTypes.add(new SetType(queryEnvironment, receiverType)); } else { newReceiverTypes.add(receiverType); } @@ -570,20 +573,20 @@ public class ValidationServices extends AbstractLanguageServices { final Class<?> cls = (Class<?>)((ParameterizedType)type).getRawType(); if (List.class.isAssignableFrom(cls)) { for (IType t : getIType(((ParameterizedType)type).getActualTypeArguments()[0])) { - result.add(new SequenceType(t)); + result.add(new SequenceType(queryEnvironment, t)); } } else if (Set.class.isAssignableFrom(cls)) { for (IType t : getIType(((ParameterizedType)type).getActualTypeArguments()[0])) { - result.add(new SetType(t)); + result.add(new SetType(queryEnvironment, t)); } } else { - result.add(new SetType(new ClassType(cls))); + result.add(new SetType(queryEnvironment, new ClassType(queryEnvironment, cls))); } } else if (type instanceof Class<?>) { final Class<?> cls = (Class<?>)type; result.addAll(getIType(cls)); } else { - result.add(new ClassType(Object.class)); + result.add(new ClassType(queryEnvironment, Object.class)); } return result; @@ -600,17 +603,17 @@ public class ValidationServices extends AbstractLanguageServices { public Set<IType> getIType(final Class<?> cls) { final Set<IType> result = new LinkedHashSet<IType>(); - final Set<EClassifier> classifiers = this.ePackageProvider.getEClass(cls); + final Set<EClassifier> classifiers = queryEnvironment.getEPackageProvider().getEClass(cls); if (List.class.isAssignableFrom(cls)) { - result.add(new SequenceType(new ClassType(Object.class))); + result.add(new SequenceType(queryEnvironment, new ClassType(queryEnvironment, Object.class))); } else if (Set.class.isAssignableFrom(cls)) { - result.add(new SetType(new ClassType(Object.class))); + result.add(new SetType(queryEnvironment, new ClassType(queryEnvironment, Object.class))); } else if (classifiers != null) { for (EClassifier eCls : classifiers) { - result.add(new EClassifierType(eCls)); + result.add(new EClassifierType(queryEnvironment, eCls)); } } else { - result.add(new ClassType(cls)); + result.add(new ClassType(queryEnvironment, cls)); } return result; @@ -655,14 +658,14 @@ public class ValidationServices extends AbstractLanguageServices { } else { if (type1.isAssignableFrom(type2) || type1.getType() == EcorePackage.eINSTANCE.getEObject()) { if (type2 instanceof EClassifierLiteralType) { - result = new EClassifierType(((EClassifierLiteralType)type2).getType()); + result = new EClassifierType(queryEnvironment, ((EClassifierLiteralType)type2).getType()); } else { result = type2; } } else if (type2.isAssignableFrom(type1) || type2.getType() == EcorePackage.eINSTANCE.getEObject()) { if (type1 instanceof EClassifierLiteralType) { - result = new EClassifierType(((EClassifierLiteralType)type1).getType()); + result = new EClassifierType(queryEnvironment, ((EClassifierLiteralType)type1).getType()); } else { result = type1; } diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/BasicLookupEngine.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/BasicLookupEngine.java index 215e1abe0..48dabdb87 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/BasicLookupEngine.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/BasicLookupEngine.java @@ -21,6 +21,8 @@ import java.util.Map; import java.util.Set; import org.eclipse.acceleo.query.runtime.CrossReferenceProvider; +import org.eclipse.acceleo.query.runtime.ILookupEngine; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; import org.eclipse.acceleo.query.runtime.IService; import org.eclipse.acceleo.query.runtime.IServiceProvider; import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException; @@ -30,12 +32,7 @@ import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException; * * @author <a href="mailto:romain.guider@obeo.fr">Romain Guider</a> */ -public class BasicLookupEngine { - - /** - * Message used when a service cannot be instanciated. - */ - public static final String INSTANTIATION_PROBLEM_MSG = "Couldn't instantiate class "; +public class BasicLookupEngine implements ILookupEngine { /** * The method name a query service that needs to use a registered cross referencer must have so it can be @@ -59,6 +56,11 @@ public class BasicLookupEngine { private final List<IService> servicesList = new ArrayList<IService>(); /** + * The {@link IReadOnlyQueryEnvironment}. + */ + private IReadOnlyQueryEnvironment queryEnvironment; + + /** * The {@link CrossReferencer} that will be used to resolve eReference requests in EObject service. */ private CrossReferenceProvider crossReferencer; @@ -66,19 +68,19 @@ public class BasicLookupEngine { /** * Constructor. Initializes the lookup engine with a cross referencer. * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param crossReferencer * The {@link CrossReferencer} that will be used to resolve eReference requests in EObject * service. */ - public BasicLookupEngine(CrossReferenceProvider crossReferencer) { + public BasicLookupEngine(IReadOnlyQueryEnvironment queryEnvironment, + CrossReferenceProvider crossReferencer) { + this.queryEnvironment = queryEnvironment; this.crossReferencer = crossReferencer; } - /** - * Returns the {@link CrossReferencer} that this engine uses. - * - * @return The {@link CrossReferencer} that this engine uses. - */ + @Override public CrossReferenceProvider getCrossReferencer() { return crossReferencer; } @@ -173,19 +175,7 @@ public class BasicLookupEngine { return false; } - /** - * Returns the service that has the specified name and that best matches the specified argument types if - * any is found. Services are ordered according to their parameter types. A type <em>T1</em> is lower than - * a type <em>T2</em> if <em>T1</em>is a sub-class of <em>T2</em>. A method <em>M1</em> is lower than a - * method <em>M2</em> if all the types of the former are lower than the type of the later at the same - * index. - * - * @param name - * the name of the service to retrieve. - * @param argumentTypes - * the types of the arguments to best match. - * @return the best service's match of the registered services if any. - */ + @Override public IService lookup(String name, Class<?>[] argumentTypes) { List<IService> multiMethod = getMultimethod(name, argumentTypes.length); if (multiMethod == null) { @@ -203,28 +193,13 @@ public class BasicLookupEngine { } } - /** - * Tells if a given method is considered as a service to provide when querying. - * - * @param method - * the method we want to know if it must be considered as a service to provide when querying. - * @return true if a given method is considered as a service to provide when querying. False otherwise. - */ - public boolean registerMethod(Method method) { + @Override + public boolean isServiceMethod(Method method) { boolean objectMethod = method.getDeclaringClass() != Object.class; return objectMethod; } - /** - * Tells if the given method is the one that indicates we have to set the cross referencer to the service - * instance. - * - * @param method - * The method we want to know if it the one that indicates we have to set the cross referencer - * to the service instance. - * @return true if the given method is the one that indicates we have to set the cross referencer to the - * service instance. False otherwise. - */ + @Override public boolean isCrossReferencerMethod(Method method) { // We do not register java.lang.Object method as // having an expression calling the 'wait' or the notify service @@ -244,7 +219,7 @@ public class BasicLookupEngine { * if the specified class doesn't follow the acceleo package rules. */ public void addServices(IServiceProvider provider) throws InvalidAcceleoPackageException { - for (IService service : provider.getServices(this)) { + for (IService service : provider.getServices(queryEnvironment)) { final List<IService> multiMethod = getOrCreateMultimethod(service.getServiceMethod().getName(), service.getServiceMethod().getParameterTypes().length); multiMethod.add(service); @@ -262,16 +237,26 @@ public class BasicLookupEngine { */ public void addServices(Class<?> newServices) throws InvalidAcceleoPackageException { try { - Constructor<?> cstr = newServices.getConstructor(new Class[] {}); - Object instance = cstr.newInstance(new Object[] {}); + Constructor<?> cstr = null; + Object instance = null; + try { + cstr = newServices.getConstructor(new Class[] {}); + instance = cstr.newInstance(new Object[] {}); + } catch (NoSuchMethodException e) { + try { + cstr = newServices.getConstructor(new Class[] {IReadOnlyQueryEnvironment.class }); + instance = cstr.newInstance(new Object[] {queryEnvironment }); + } catch (NoSuchMethodException e1) { + throw new InvalidAcceleoPackageException(PACKAGE_PROBLEM_MSG + + newServices.getCanonicalName(), e); + } + } if (instance instanceof IServiceProvider) { addServices((IServiceProvider)instance); } else { Method[] methods = newServices.getMethods(); getServicesFromInstance(instance, methods); } - } catch (NoSuchMethodException e) { - throw new InvalidAcceleoPackageException(PACKAGE_PROBLEM_MSG + newServices.getCanonicalName(), e); } catch (SecurityException e) { throw new InvalidAcceleoPackageException(PACKAGE_PROBLEM_MSG + newServices.getCanonicalName(), e); } catch (InstantiationException e) { @@ -306,7 +291,7 @@ public class BasicLookupEngine { for (Method method : methods) { if (isCrossReferencerMethod(method)) { method.invoke(instance, crossReferencer); - } else if (registerMethod(method)) { + } else if (isServiceMethod(method)) { List<IService> multiMethod = getOrCreateMultimethod(method.getName(), method .getParameterTypes().length); final IService service = new Service(method, instance); @@ -316,13 +301,7 @@ public class BasicLookupEngine { } } - /** - * Gets the {@link Set} of known {@link IService} with a compatible receiver type. - * - * @param receiverTypes - * the receiver types - * @return the {@link Set} of known {@link IService} with a compatible receiver type - */ + @Override public Set<IService> getServices(Set<Class<?>> receiverTypes) { final Set<IService> result = new LinkedHashSet<IService>(); diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/AnyServices.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/AnyServices.java index 937e70b51..c90e261c4 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/AnyServices.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/AnyServices.java @@ -17,9 +17,9 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Set; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; import org.eclipse.acceleo.query.runtime.IService; import org.eclipse.acceleo.query.runtime.impl.AbstractServiceProvider; -import org.eclipse.acceleo.query.runtime.impl.EPackageProvider; import org.eclipse.acceleo.query.runtime.impl.EvaluationServices; import org.eclipse.acceleo.query.runtime.impl.ValidationServices; import org.eclipse.acceleo.query.runtime.lookup.basic.Service; @@ -42,16 +42,20 @@ import org.eclipse.emf.ecore.EObject; public class AnyServices extends AbstractServiceProvider { /** - * The Class constructor. + * The {@link IReadOnlyQueryEnvironment}. */ - public AnyServices() { - } + private final IReadOnlyQueryEnvironment queryEnvironment; /** - * {@inheritDoc} - * - * @see org.eclipse.acceleo.query.runtime.impl.AbstractServiceProvider#getService(java.lang.reflect.Method) + * Constructor. + * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} */ + public AnyServices(IReadOnlyQueryEnvironment queryEnvironment) { + this.queryEnvironment = queryEnvironment; + } + @Override protected IService getService(Method publicMethod) { final IService result; @@ -60,15 +64,15 @@ public class AnyServices extends AbstractServiceProvider { result = new FilterService(publicMethod, this) { @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment environment, List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); final Object type = argTypes.get(1).getType(); if (type instanceof EClassifier) { - result.add(new EClassifierType((EClassifier)type)); + result.add(new EClassifierType(environment, (EClassifier)type)); } else if (type instanceof Class) { - result.add(new ClassType((Class<?>)type)); + result.add(new ClassType(environment, (Class<?>)type)); } else if (type != null) { result.add(services.nothing("Don't know what kind of type is %s", type)); } else { @@ -182,25 +186,6 @@ public class AnyServices extends AbstractServiceProvider { return o1.compareTo(o2) >= 0; } - // - // /** - // * Handles calls to the "eContainer" operation. This will retrieve the very first container in the - // * hierarchy that is of type <em>filter</em>. - // * - // * @param o1 - // * the reference EObject we seek to retrieve a feature value of. - // * @param filter - // * Types of the container we seek to retrieve. - // * @return The first container of type <em>filter</em>. - // */ - // public Object eContainer(EObject o1, EClassifier filter) { - // EObject container = o1.eContainer(); - // while (container != null && !filter.isInstance(container)) { - // container = container.eContainer(); - // } - // return container; - // } - /** * Returns the string representation of self object to which we concatenated the string "s". * @@ -269,7 +254,12 @@ public class AnyServices extends AbstractServiceProvider { result = false; } } else if (type instanceof EDataType) { - result = ((EClassifier)type).getInstanceClass().isAssignableFrom(object.getClass()); + final Class<?> cls = queryEnvironment.getEPackageProvider().getClass((EClassifier)type); + if (cls == null) { + throw new IllegalArgumentException(String.format( + "%s is not registered in the current environment", type)); + } + result = cls.isAssignableFrom(object.getClass()); } else if (type instanceof Class<?>) { result = ((Class<?>)type).isAssignableFrom(object.getClass()); } else { @@ -307,7 +297,12 @@ public class AnyServices extends AbstractServiceProvider { result = false; } } else if (type instanceof EDataType) { - result = ((EClassifier)type).getInstanceClass().isAssignableFrom(object.getClass()); + final Class<?> cls = queryEnvironment.getEPackageProvider().getClass((EClassifier)type); + if (cls == null) { + throw new IllegalArgumentException(String.format( + "%s is not registered in the current environment", type)); + } + result = cls.isAssignableFrom(object.getClass()); } else if (type instanceof Class<?>) { result = ((Class<?>)type).equals(object.getClass()); } else { diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/CollectionServices.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/CollectionServices.java index e0ee99d4e..d47f5f51f 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/CollectionServices.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/CollectionServices.java @@ -25,9 +25,10 @@ import java.util.Map.Entry; import java.util.Set; import org.eclipse.acceleo.query.ast.Lambda; +import org.eclipse.acceleo.query.runtime.IEPackageProvider; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; import org.eclipse.acceleo.query.runtime.IService; import org.eclipse.acceleo.query.runtime.impl.AbstractServiceProvider; -import org.eclipse.acceleo.query.runtime.impl.EPackageProvider; import org.eclipse.acceleo.query.runtime.impl.ValidationServices; import org.eclipse.acceleo.query.runtime.lookup.basic.Service; import org.eclipse.acceleo.query.validation.type.EClassifierLiteralType; @@ -73,12 +74,13 @@ public class CollectionServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); final LambdaType lambdaType = (LambdaType)argTypes.get(1); final Object lambdaExpressionType = lambdaType.getLambdaExpressionType().getType(); - if (isBooleanType(lambdaExpressionType)) { - result.addAll(super.getType(services, provider, argTypes)); + if (isBooleanType(queryEnvironment, lambdaExpressionType)) { + result.addAll(super.getType(services, queryEnvironment, argTypes)); } else { result.add(services.nothing("expression in %s must return a boolean", getServiceMethod() .getName())); @@ -107,15 +109,16 @@ public class CollectionServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); final LambdaType lambdaType = (LambdaType)argTypes.get(1); final Object lambdaExpressionType = lambdaType.getLambdaExpressionType().getType(); - if (isBooleanType(lambdaExpressionType)) { + if (isBooleanType(queryEnvironment, lambdaExpressionType)) { IType lambdaEvaluatorType = lambdaType.getLambdaEvaluatorType(); if (lambdaEvaluatorType instanceof EClassifierLiteralType) { - lambdaEvaluatorType = new EClassifierType(((EClassifierLiteralType)lambdaEvaluatorType) - .getType()); + lambdaEvaluatorType = new EClassifierType(queryEnvironment, + ((EClassifierLiteralType)lambdaEvaluatorType).getType()); } result.add(lambdaEvaluatorType); } else { @@ -145,27 +148,24 @@ public class CollectionServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (List.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SequenceType(((ICollectionType)argTypes.get(0)).getCollectionType())); - result.add(new SequenceType(argTypes.get(1))); + result.add(new SequenceType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); + result.add(new SequenceType(queryEnvironment, argTypes.get(1))); } else if (Set.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SetType(((ICollectionType)argTypes.get(0)).getCollectionType())); - result.add(new SetType(argTypes.get(1))); + result.add(new SetType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); + result.add(new SetType(queryEnvironment, argTypes.get(1))); } return result; } - /** - * {@inheritDoc} - * - * @see org.eclipse.acceleo.query.runtime.impl.AbstractService#validateAllType(org.eclipse.acceleo.query.runtime.impl.ValidationServices, - * org.eclipse.acceleo.query.runtime.impl.EPackageProvider, java.util.Map) - */ @Override - public Set<IType> validateAllType(ValidationServices services, EPackageProvider provider, - Map<List<IType>, Set<IType>> allTypes) { + public Set<IType> validateAllType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, Map<List<IType>, Set<IType>> allTypes) { final Set<IType> result = new LinkedHashSet<IType>(); final StringBuilder builder = new StringBuilder(); @@ -209,13 +209,14 @@ public class CollectionServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); final LambdaType lambdaType = (LambdaType)argTypes.get(1); if (List.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SequenceType(lambdaType.getLambdaExpressionType())); + result.add(new SequenceType(queryEnvironment, lambdaType.getLambdaExpressionType())); } else if (Set.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SetType(lambdaType.getLambdaExpressionType())); + result.add(new SetType(queryEnvironment, lambdaType.getLambdaExpressionType())); } return result; } @@ -241,20 +242,21 @@ public class CollectionServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); final LambdaType lambdaType = (LambdaType)argTypes.get(1); final Object lambdaExpressionType = lambdaType.getLambdaExpressionType().getType(); - if (isBooleanType(lambdaExpressionType)) { + if (isBooleanType(queryEnvironment, lambdaExpressionType)) { IType lambdaEvaluatorType = lambdaType.getLambdaEvaluatorType(); if (lambdaEvaluatorType instanceof EClassifierLiteralType) { - lambdaEvaluatorType = new EClassifierType(((EClassifierLiteralType)lambdaEvaluatorType) - .getType()); + lambdaEvaluatorType = new EClassifierType(queryEnvironment, + ((EClassifierLiteralType)lambdaEvaluatorType).getType()); } if (List.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SequenceType(lambdaEvaluatorType)); + result.add(new SequenceType(queryEnvironment, lambdaEvaluatorType)); } else if (Set.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SetType(lambdaEvaluatorType)); + result.add(new SetType(queryEnvironment, lambdaEvaluatorType)); } } else { result.add(services.nothing("expression in a select must return a boolean")); @@ -283,16 +285,19 @@ public class CollectionServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); final LambdaType lambdaType = (LambdaType)argTypes.get(1); final Object lambdaExpressionType = lambdaType.getLambdaExpressionType().getType(); - if (isBooleanType(lambdaExpressionType)) { + if (isBooleanType(queryEnvironment, lambdaExpressionType)) { if (List.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SequenceType(((ICollectionType)argTypes.get(0)).getCollectionType())); + result.add(new SequenceType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); } else if (Set.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SetType(((ICollectionType)argTypes.get(0)).getCollectionType())); + result.add(new SetType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); } } else { result.add(services.nothing("expression in a reject must return a boolean")); @@ -322,7 +327,8 @@ public class CollectionServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); result.add(((ICollectionType)argTypes.get(0)).getCollectionType()); @@ -352,20 +358,17 @@ public class CollectionServices extends AbstractServiceProvider { super(serviceMethod, serviceInstance); } - /** - * {@inheritDoc} - * - * @see org.eclipse.acceleo.query.runtime.impl.AbstractService#getType(org.eclipse.acceleo.query.runtime.impl.ValidationServices, - * java.util.List) - */ @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (List.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SequenceType(((ICollectionType)argTypes.get(0)).getCollectionType())); + result.add(new SequenceType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); } else if (Set.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SetType(((ICollectionType)argTypes.get(0)).getCollectionType())); + result.add(new SetType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); } return result; @@ -393,36 +396,29 @@ public class CollectionServices extends AbstractServiceProvider { super(serviceMethod, serviceInstance); } - /** - * {@inheritDoc} - * - * @see org.eclipse.acceleo.query.runtime.impl.AbstractService#getType(org.eclipse.acceleo.query.runtime.impl.ValidationServices, - * java.util.List) - */ @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (List.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SequenceType(((ICollectionType)argTypes.get(0)).getCollectionType())); - result.add(new SequenceType(((ICollectionType)argTypes.get(1)).getCollectionType())); + result.add(new SequenceType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); + result.add(new SequenceType(queryEnvironment, ((ICollectionType)argTypes.get(1)) + .getCollectionType())); } else if (Set.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SetType(((ICollectionType)argTypes.get(0)).getCollectionType())); - result.add(new SetType(((ICollectionType)argTypes.get(1)).getCollectionType())); + result.add(new SetType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); + result.add(new SetType(queryEnvironment, ((ICollectionType)argTypes.get(1)) + .getCollectionType())); } return result; } - /** - * {@inheritDoc} - * - * @see org.eclipse.acceleo.query.runtime.impl.AbstractService#validateAllType(org.eclipse.acceleo.query.runtime.impl.ValidationServices, - * org.eclipse.acceleo.query.runtime.impl.EPackageProvider, java.util.Map) - */ @Override - public Set<IType> validateAllType(ValidationServices services, EPackageProvider provider, - Map<List<IType>, Set<IType>> allTypes) { + public Set<IType> validateAllType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, Map<List<IType>, Set<IType>> allTypes) { final Set<IType> result = new LinkedHashSet<IType>(); final StringBuilder builder = new StringBuilder(); @@ -470,16 +466,16 @@ public class CollectionServices extends AbstractServiceProvider { } @Override - public java.util.Set<IType> getType(ValidationServices services, EPackageProvider provider, - java.util.List<IType> argTypes) { + public java.util.Set<IType> getType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, java.util.List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); - final EClassifierType rawType = new EClassifierType(((EClassifierLiteralType)argTypes.get(1)) - .getType()); + final EClassifierType rawType = new EClassifierType(queryEnvironment, + ((EClassifierLiteralType)argTypes.get(1)).getType()); if (List.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SequenceType(rawType)); + result.add(new SequenceType(queryEnvironment, rawType)); } else if (Set.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SetType(rawType)); + result.add(new SetType(queryEnvironment, rawType)); } return result; @@ -507,12 +503,15 @@ public class CollectionServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (List.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SequenceType(((ICollectionType)argTypes.get(0)).getCollectionType())); + result.add(new SequenceType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); } else if (Set.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SetType(((ICollectionType)argTypes.get(0)).getCollectionType())); + result.add(new SetType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); } return result; } @@ -539,14 +538,17 @@ public class CollectionServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (List.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SequenceType(((ICollectionType)argTypes.get(0)).getCollectionType())); - result.add(new SequenceType(argTypes.get(2))); + result.add(new SequenceType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); + result.add(new SequenceType(queryEnvironment, argTypes.get(2))); } else if (Set.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SetType(((ICollectionType)argTypes.get(0)).getCollectionType())); - result.add(new SetType(argTypes.get(2))); + result.add(new SetType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); + result.add(new SetType(queryEnvironment, argTypes.get(2))); } return result; } @@ -572,7 +574,8 @@ public class CollectionServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); IType selfRawType = ((ICollectionType)argTypes.get(0)).getCollectionType(); @@ -582,9 +585,9 @@ public class CollectionServices extends AbstractServiceProvider { if (loweredType != null) { resultRawTypes.add(loweredType); } else if (selfRawType.getType() instanceof EClass && otherRawType.getType() instanceof EClass) { - for (EClass eCls : getSubTypesTopIntersection(provider, (EClass)selfRawType.getType(), - (EClass)otherRawType.getType())) { - resultRawTypes.add(new EClassifierType(eCls)); + for (EClass eCls : getSubTypesTopIntersection(queryEnvironment.getEPackageProvider(), + (EClass)selfRawType.getType(), (EClass)otherRawType.getType())) { + resultRawTypes.add(new EClassifierType(queryEnvironment, eCls)); } if (resultRawTypes.isEmpty()) { resultRawTypes.add(services.nothing("Nothing left after intersection of %s and %s", @@ -596,26 +599,20 @@ public class CollectionServices extends AbstractServiceProvider { } if (List.class.isAssignableFrom(getServiceMethod().getReturnType())) { for (IType resultRawType : resultRawTypes) { - result.add(new SequenceType(resultRawType)); + result.add(new SequenceType(queryEnvironment, resultRawType)); } } else if (Set.class.isAssignableFrom(getServiceMethod().getReturnType())) { for (IType resultRawType : resultRawTypes) { - result.add(new SetType(resultRawType)); + result.add(new SetType(queryEnvironment, resultRawType)); } } return result; } - /** - * {@inheritDoc} - * - * @see org.eclipse.acceleo.query.runtime.impl.AbstractService#validateAllType(org.eclipse.acceleo.query.runtime.impl.ValidationServices, - * org.eclipse.acceleo.query.runtime.impl.EPackageProvider, java.util.Map) - */ @Override - public Set<IType> validateAllType(ValidationServices services, EPackageProvider provider, - Map<List<IType>, Set<IType>> allTypes) { + public Set<IType> validateAllType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, Map<List<IType>, Set<IType>> allTypes) { final Set<IType> result = new LinkedHashSet<IType>(); final StringBuilder builder = new StringBuilder(); @@ -640,18 +637,18 @@ public class CollectionServices extends AbstractServiceProvider { /** * Gets the {@link Set} of the higher {@link EClass} in the super types hierarchy inheriting from both - * given {@link EClass} according to the given {@link EPackageProvider} . + * given {@link EClass} according to the given {@link IEPackageProvider} . * * @param provider - * the {@link EPackageProvider} + * the {@link IEPackageProvider} * @param eCls1 * the first {@link EClass} * @param eCls2 * the second {@link EClass} * @return the {@link Set} of the higher {@link EClass} in the super types hierarchy inheriting from - * both given {@link EClass} according to the given {@link EPackageProvider} + * both given {@link EClass} according to the given {@link IEPackageProvider} */ - private Set<EClass> getSubTypesTopIntersection(EPackageProvider provider, EClass eCls1, EClass eCls2) { + private Set<EClass> getSubTypesTopIntersection(IEPackageProvider provider, EClass eCls1, EClass eCls2) { final Set<EClass> result = new LinkedHashSet<EClass>(); final Set<EClass> subTypes1 = provider.getAllSubTypes(eCls1); @@ -683,11 +680,6 @@ public class CollectionServices extends AbstractServiceProvider { } } - /** - * {@inheritDoc} - * - * @see org.eclipse.acceleo.query.runtime.impl.AbstractServiceProvider#getService(java.lang.reflect.Method) - */ @Override protected IService getService(Method publicMethod) { final IService result; @@ -721,12 +713,13 @@ public class CollectionServices extends AbstractServiceProvider { result = new Service(publicMethod, this) { @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, - List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); - result.add(new SequenceType(((ICollectionType)argTypes.get(0)).getCollectionType())); - result.add(new SequenceType(argTypes.get(1))); + result.add(new SequenceType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); + result.add(new SequenceType(queryEnvironment, argTypes.get(1))); return result; } @@ -735,14 +728,15 @@ public class CollectionServices extends AbstractServiceProvider { result = new Service(publicMethod, this) { @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, - List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); - result.add(new SequenceType(((ICollectionType)argTypes.get(0)).getCollectionType())); - result.add(new SequenceType(argTypes.get(1))); - result.add(new SequenceType(argTypes.get(2))); - result.add(new SequenceType(argTypes.get(3))); + result.add(new SequenceType(queryEnvironment, ((ICollectionType)argTypes.get(0)) + .getCollectionType())); + result.add(new SequenceType(queryEnvironment, argTypes.get(1))); + result.add(new SequenceType(queryEnvironment, argTypes.get(2))); + result.add(new SequenceType(queryEnvironment, argTypes.get(3))); return result; } @@ -768,15 +762,24 @@ public class CollectionServices extends AbstractServiceProvider { /** * Tells if the given {@link Object} is a is a boolean {@link org.eclipse.emf.ecore.EDataType EDataType}. * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param type * the {@link org.eclipse.emf.ecore.EDataType EDataType} * @return <code>true</code> if the given {@link Object} is a is a boolean * {@link org.eclipse.emf.ecore.EDataType EDataType}, <code>false</code> otherwise */ - private static boolean isBooleanType(Object type) { - return type instanceof EClassifier - && (((EClassifier)type).getInstanceClass() == Boolean.class || ((EClassifier)type) - .getInstanceClass() == boolean.class); + private static boolean isBooleanType(IReadOnlyQueryEnvironment queryEnvironment, Object type) { + final boolean result; + + if (type instanceof EClassifier) { + final Class<?> typeClass = queryEnvironment.getEPackageProvider().getClass((EClassifier)type); + result = typeClass == Boolean.class || typeClass == boolean.class; + } else { + result = false; + } + + return result; } /** diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/EObjectServices.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/EObjectServices.java index 576ca1f63..e7a9edc49 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/EObjectServices.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/EObjectServices.java @@ -24,9 +24,9 @@ import java.util.ListIterator; import java.util.Set; import org.eclipse.acceleo.query.runtime.CrossReferenceProvider; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; import org.eclipse.acceleo.query.runtime.IService; import org.eclipse.acceleo.query.runtime.impl.AbstractServiceProvider; -import org.eclipse.acceleo.query.runtime.impl.EPackageProvider; import org.eclipse.acceleo.query.runtime.impl.ValidationServices; import org.eclipse.acceleo.query.runtime.lookup.basic.Service; import org.eclipse.acceleo.query.validation.type.EClassifierLiteralType; @@ -70,23 +70,24 @@ public class EObjectServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.get(0).getType() instanceof EClass) { final EClass eCls = (EClass)argTypes.get(0).getType(); if (eCls == EcorePackage.eINSTANCE.getEObject()) { if (argTypes.size() == 1) { - result.add(new SequenceType(argTypes.get(0))); + result.add(new SequenceType(queryEnvironment, argTypes.get(0))); } else if (argTypes.size() == 2) { - result.add(new SequenceType(new EClassifierType(((EClassifierLiteralType)argTypes - .get(1)).getType()))); + result.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + ((EClassifierLiteralType)argTypes.get(1)).getType()))); } } else { - result.addAll(getTypeForSpecificType(services, provider, argTypes, eCls)); + result.addAll(getTypeForSpecificType(services, queryEnvironment, argTypes, eCls)); } } else { - result.add(new SequenceType(services.nothing( + result.add(new SequenceType(queryEnvironment, services.nothing( "Only EClass can be contained into other EClasses not %s", argTypes.get(0)))); } @@ -99,8 +100,8 @@ public class EObjectServices extends AbstractServiceProvider { * * @param services * the {@link ValidationServices} - * @param provider - * the {@link EPackageProvider} + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param argTypes * arguments {@link IType} * @param receiverEClass @@ -108,27 +109,32 @@ public class EObjectServices extends AbstractServiceProvider { * @return the {@link IType} of elements returned by the service when the receiver type is not the * {@link EObject} {@link EClass} */ - private Set<IType> getTypeForSpecificType(ValidationServices services, EPackageProvider provider, - List<IType> argTypes, final EClass receiverEClass) { + private Set<IType> getTypeForSpecificType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, List<IType> argTypes, final EClass receiverEClass) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.size() == 1) { - for (EClass containingEClass : provider.getAllContainingEClasses(receiverEClass)) { - result.add(new SequenceType(new EClassifierType(containingEClass))); + for (EClass containingEClass : queryEnvironment.getEPackageProvider() + .getAllContainingEClasses(receiverEClass)) { + result.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + containingEClass))); } if (result.isEmpty()) { - result.add(new SequenceType(services.nothing("%s can't be contained", argTypes.get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing("%s can't be contained", + argTypes.get(0)))); } } else if (argTypes.size() == 2) { final IType filterType = argTypes.get(1); - for (EClass containingEClass : provider.getAllContainingEClasses(receiverEClass)) { - final IType lowerType = services.lower(new EClassifierType(containingEClass), filterType); + for (EClass containingEClass : queryEnvironment.getEPackageProvider() + .getAllContainingEClasses(receiverEClass)) { + final IType lowerType = services.lower(new EClassifierType(queryEnvironment, + containingEClass), filterType); if (lowerType != null) { - result.add(new SequenceType(lowerType)); + result.add(new SequenceType(queryEnvironment, lowerType)); } } if (result.isEmpty()) { - result.add(new SequenceType(services.nothing( + result.add(new SequenceType(queryEnvironment, services.nothing( "%s can't contain directly or indirectly %s", filterType, argTypes.get(0)))); } } @@ -158,7 +164,8 @@ public class EObjectServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.get(0).getType() instanceof EClass) { @@ -167,10 +174,11 @@ public class EObjectServices extends AbstractServiceProvider { if (argTypes.size() == 1) { result.add(argTypes.get(0)); } else if (argTypes.size() == 2) { - result.add(new EClassifierType(((EClassifierLiteralType)argTypes.get(1)).getType())); + result.add(new EClassifierType(queryEnvironment, ((EClassifierLiteralType)argTypes + .get(1)).getType())); } } else { - result.addAll(getTypeForSpecificType(services, provider, argTypes, eCls)); + result.addAll(getTypeForSpecificType(services, queryEnvironment, argTypes, eCls)); } } else { result.add(services.nothing("Only EClass can be contained into other EClasses not %s", @@ -186,8 +194,8 @@ public class EObjectServices extends AbstractServiceProvider { * * @param services * the {@link ValidationServices} - * @param provider - * the {@link EPackageProvider} + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param argTypes * arguments {@link IType} * @param receiverEClass @@ -195,21 +203,24 @@ public class EObjectServices extends AbstractServiceProvider { * @return the {@link IType} of elements returned by the service when the receiver type is not the * {@link EObject} {@link EClass} */ - private Set<IType> getTypeForSpecificType(ValidationServices services, EPackageProvider provider, - List<IType> argTypes, final EClass receiverEClass) { + private Set<IType> getTypeForSpecificType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, List<IType> argTypes, final EClass receiverEClass) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.size() == 1) { - for (EClass containingEClass : provider.getContainingEClasses(receiverEClass)) { - result.add(new EClassifierType(containingEClass)); + for (EClass containingEClass : queryEnvironment.getEPackageProvider().getContainingEClasses( + receiverEClass)) { + result.add(new EClassifierType(queryEnvironment, containingEClass)); } if (result.isEmpty()) { result.add(services.nothing("%s can't be contained", argTypes.get(0))); } } else if (argTypes.size() == 2) { final IType filterType = argTypes.get(1); - for (EClass containingEClass : provider.getAllContainingEClasses(receiverEClass)) { - final IType lowerType = services.lower(new EClassifierType(containingEClass), filterType); + for (EClass containingEClass : queryEnvironment.getEPackageProvider() + .getAllContainingEClasses(receiverEClass)) { + final IType lowerType = services.lower(new EClassifierType(queryEnvironment, + containingEClass), filterType); if (lowerType != null) { result.add(lowerType); } @@ -245,24 +256,25 @@ public class EObjectServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.get(0).getType() instanceof EClass) { final EClass eCls = (EClass)argTypes.get(0).getType(); if (eCls == EcorePackage.eINSTANCE.getEObject()) { if (argTypes.size() == 1) { - result.add(new SequenceType(argTypes.get(0))); + result.add(new SequenceType(queryEnvironment, argTypes.get(0))); } else if (argTypes.size() == 2) { - result.add(new SequenceType(new EClassifierType(((EClassifierLiteralType)argTypes - .get(1)).getType()))); + result.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + ((EClassifierLiteralType)argTypes.get(1)).getType()))); } } else { - result.addAll(getTypeForSpecificType(services, provider, argTypes, eCls)); + result.addAll(getTypeForSpecificType(services, queryEnvironment, argTypes, eCls)); } } else { - result.add(new SequenceType(services.nothing("Only EClass can contain other EClasses not %s", - argTypes.get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing( + "Only EClass can contain other EClasses not %s", argTypes.get(0)))); } return result; @@ -274,8 +286,8 @@ public class EObjectServices extends AbstractServiceProvider { * * @param services * the {@link ValidationServices} - * @param provider - * the {@link EPackageProvider} + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param argTypes * arguments {@link IType} * @param receiverEClass @@ -283,31 +295,35 @@ public class EObjectServices extends AbstractServiceProvider { * @return the {@link IType} of elements returned by the service when the receiver type is not the * {@link EObject} {@link EClass} */ - private Set<IType> getTypeForSpecificType(ValidationServices services, EPackageProvider provider, - List<IType> argTypes, final EClass receiverEClass) { + private Set<IType> getTypeForSpecificType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, List<IType> argTypes, final EClass receiverEClass) { final Set<IType> result = new LinkedHashSet<IType>(); final Set<IType> containedTypes = new LinkedHashSet<IType>(); - for (EClass contained : provider.getContainedEClasses(receiverEClass)) { - containedTypes.add(new SequenceType(new EClassifierType(contained))); + for (EClass contained : queryEnvironment.getEPackageProvider().getContainedEClasses( + receiverEClass)) { + containedTypes.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + contained))); } if (argTypes.size() == 1) { result.addAll(containedTypes); if (result.isEmpty()) { - result.add(new SequenceType(services.nothing("%s doesn't contain any other EClass", - argTypes.get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing( + "%s doesn't contain any other EClass", argTypes.get(0)))); } } else if (argTypes.size() == 2) { final IType filterType = argTypes.get(1); - for (EClass containedEClass : provider.getContainedEClasses(receiverEClass)) { - final IType lowerType = services.lower(new EClassifierType(containedEClass), filterType); + for (EClass containedEClass : queryEnvironment.getEPackageProvider().getContainedEClasses( + receiverEClass)) { + final IType lowerType = services.lower(new EClassifierType(queryEnvironment, + containedEClass), filterType); if (lowerType != null) { - result.add(new SequenceType(lowerType)); + result.add(new SequenceType(queryEnvironment, lowerType)); } } if (result.isEmpty()) { - result.add(new SequenceType(services.nothing("%s can't contain %s direclty", argTypes - .get(0), filterType))); + result.add(new SequenceType(queryEnvironment, services.nothing( + "%s can't contain %s direclty", argTypes.get(0), filterType))); } } @@ -336,24 +352,25 @@ public class EObjectServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.get(0).getType() instanceof EClass) { final EClass eCls = (EClass)argTypes.get(0).getType(); if (eCls == EcorePackage.eINSTANCE.getEObject()) { if (argTypes.size() == 1) { - result.add(new SequenceType(argTypes.get(0))); + result.add(new SequenceType(queryEnvironment, argTypes.get(0))); } else if (argTypes.size() == 2) { - result.add(new SequenceType(new EClassifierType(((EClassifierLiteralType)argTypes - .get(1)).getType()))); + result.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + ((EClassifierLiteralType)argTypes.get(1)).getType()))); } } else { - result.addAll(getTypeForSpecificType(services, provider, argTypes, eCls)); + result.addAll(getTypeForSpecificType(services, queryEnvironment, argTypes, eCls)); } } else { - result.add(new SequenceType(services.nothing("Only EClass can contain other EClasses not %s", - argTypes.get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing( + "Only EClass can contain other EClasses not %s", argTypes.get(0)))); } return result; @@ -365,8 +382,8 @@ public class EObjectServices extends AbstractServiceProvider { * * @param services * the {@link ValidationServices} - * @param provider - * the {@link EPackageProvider} + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param argTypes * arguments {@link IType} * @param receiverEClass @@ -374,30 +391,34 @@ public class EObjectServices extends AbstractServiceProvider { * @return the {@link IType} of elements returned by the service when the receiver type is not the * {@link EObject} {@link EClass} */ - private Set<IType> getTypeForSpecificType(ValidationServices services, EPackageProvider provider, - List<IType> argTypes, final EClass receiverEClass) { + private Set<IType> getTypeForSpecificType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, List<IType> argTypes, final EClass receiverEClass) { final Set<IType> result = new LinkedHashSet<IType>(); final Set<IType> containedTypes = new LinkedHashSet<IType>(); - for (EClass contained : provider.getAllContainedEClasses(receiverEClass)) { - containedTypes.add(new SequenceType(new EClassifierType(contained))); + for (EClass contained : queryEnvironment.getEPackageProvider().getAllContainedEClasses( + receiverEClass)) { + containedTypes.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + contained))); } if (argTypes.size() == 1) { result.addAll(containedTypes); if (result.isEmpty()) { - result.add(new SequenceType(services.nothing("%s doesn't contain any other EClass", - argTypes.get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing( + "%s doesn't contain any other EClass", argTypes.get(0)))); } } else if (argTypes.size() == 2) { final IType filterType = argTypes.get(1); - for (EClass containedEClass : provider.getAllContainedEClasses(receiverEClass)) { - final IType lowerType = services.lower(new EClassifierType(containedEClass), filterType); + for (EClass containedEClass : queryEnvironment.getEPackageProvider().getAllContainedEClasses( + receiverEClass)) { + final IType lowerType = services.lower(new EClassifierType(queryEnvironment, + containedEClass), filterType); if (lowerType != null) { - result.add(new SequenceType(lowerType)); + result.add(new SequenceType(queryEnvironment, lowerType)); } } if (result.isEmpty()) { - result.add(new SequenceType(services.nothing( + result.add(new SequenceType(queryEnvironment, services.nothing( "%s can't contain %s direclty or indirectly", argTypes.get(0), filterType))); } } @@ -426,24 +447,25 @@ public class EObjectServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.get(0).getType() instanceof EClass) { final EClass eCls = (EClass)argTypes.get(0).getType(); if (eCls == EcorePackage.eINSTANCE.getEObject()) { if (argTypes.size() == 1) { - result.add(new SetType(argTypes.get(0))); + result.add(new SetType(queryEnvironment, argTypes.get(0))); } else if (argTypes.size() == 2) { - result.add(new SetType(new EClassifierType(((EClassifierLiteralType)argTypes.get(1)) - .getType()))); + result.add(new SetType(queryEnvironment, new EClassifierType(queryEnvironment, + ((EClassifierLiteralType)argTypes.get(1)).getType()))); } } else { - result.addAll(getTypeForSpecificType(services, provider, argTypes, eCls)); + result.addAll(getTypeForSpecificType(services, queryEnvironment, argTypes, eCls)); } } else { - result.add(new SetType(services.nothing("Only EClass can have inverse not %s", argTypes - .get(0)))); + result.add(new SetType(queryEnvironment, services.nothing( + "Only EClass can have inverse not %s", argTypes.get(0)))); } return result; @@ -455,8 +477,8 @@ public class EObjectServices extends AbstractServiceProvider { * * @param services * the {@link ValidationServices} - * @param provider - * the {@link EPackageProvider} + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param argTypes * arguments {@link IType} * @param receiverEClass @@ -464,28 +486,33 @@ public class EObjectServices extends AbstractServiceProvider { * @return the {@link IType} of elements returned by the service when the receiver type is not the * {@link EObject} {@link EClass} */ - private Set<IType> getTypeForSpecificType(ValidationServices services, EPackageProvider provider, - List<IType> argTypes, final EClass receiverEClass) { + private Set<IType> getTypeForSpecificType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, List<IType> argTypes, final EClass receiverEClass) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.size() == 1 || !(argTypes.get(1).getType() instanceof EClassifier)) { - for (EClass inverseEClass : provider.getInverseEClasses(receiverEClass)) { - result.add(new SetType(new EClassifierType(inverseEClass))); + for (EClass inverseEClass : queryEnvironment.getEPackageProvider().getInverseEClasses( + receiverEClass)) { + result.add(new SetType(queryEnvironment, new EClassifierType(queryEnvironment, + inverseEClass))); } if (result.isEmpty()) { - result.add(new SetType(services.nothing("%s don't have inverse", argTypes.get(0)))); + result.add(new SetType(queryEnvironment, services.nothing("%s don't have inverse", + argTypes.get(0)))); } } else if (argTypes.size() == 2) { final IType filterType = argTypes.get(1); - for (EClass inverseEClass : provider.getInverseEClasses(receiverEClass)) { - final IType lowerType = services.lower(new EClassifierType(inverseEClass), filterType); + for (EClass inverseEClass : queryEnvironment.getEPackageProvider().getInverseEClasses( + receiverEClass)) { + final IType lowerType = services.lower(new EClassifierType(queryEnvironment, + inverseEClass), filterType); if (lowerType != null) { - result.add(new SetType(lowerType)); + result.add(new SetType(queryEnvironment, lowerType)); } } if (result.isEmpty()) { - result.add(new SetType(services.nothing("%s don't have inverse to %s", argTypes.get(0), - filterType))); + result.add(new SetType(queryEnvironment, services.nothing("%s don't have inverse to %s", + argTypes.get(0), filterType))); } } @@ -514,23 +541,24 @@ public class EObjectServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.get(0).getType() instanceof EClass) { final EClass eCls = (EClass)argTypes.get(0).getType(); if (eCls == EcorePackage.eINSTANCE.getEObject()) { if (argTypes.size() == 1) { - result.add(new SequenceType(argTypes.get(0))); + result.add(new SequenceType(queryEnvironment, argTypes.get(0))); } else if (argTypes.size() == 2) { - result.add(new SequenceType(new EClassifierType(((EClassifierLiteralType)argTypes - .get(1)).getType()))); + result.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + ((EClassifierLiteralType)argTypes.get(1)).getType()))); } } else { - result.addAll(getTypeForSpecificType(services, provider, argTypes, eCls)); + result.addAll(getTypeForSpecificType(services, queryEnvironment, argTypes, eCls)); } } else { - result.add(new SequenceType(services.nothing( + result.add(new SequenceType(queryEnvironment, services.nothing( "Only EClass can have following siblings not %s", argTypes.get(0)))); } @@ -543,8 +571,8 @@ public class EObjectServices extends AbstractServiceProvider { * * @param services * the {@link ValidationServices} - * @param provider - * the {@link EPackageProvider} + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param argTypes * arguments {@link IType} * @param receiverEClass @@ -552,29 +580,33 @@ public class EObjectServices extends AbstractServiceProvider { * @return the {@link IType} of elements returned by the service when the receiver type is not the * {@link EObject} {@link EClass} */ - private Set<IType> getTypeForSpecificType(ValidationServices services, EPackageProvider provider, - List<IType> argTypes, final EClass receiverEClass) { + private Set<IType> getTypeForSpecificType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, List<IType> argTypes, final EClass receiverEClass) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.size() == 1) { - for (EClass containingEClass : provider.getFollowingSiblingsEClasses(receiverEClass)) { - result.add(new SequenceType(new EClassifierType(containingEClass))); + for (EClass containingEClass : queryEnvironment.getEPackageProvider() + .getFollowingSiblingsEClasses(receiverEClass)) { + result.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + containingEClass))); } if (result.isEmpty()) { - result.add(new SequenceType(services.nothing("%s can't have following siblings", argTypes - .get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing( + "%s can't have following siblings", argTypes.get(0)))); } } else if (argTypes.size() == 2) { final IType filterType = argTypes.get(1); - for (EClass containingEClass : provider.getFollowingSiblingsEClasses(receiverEClass)) { - final IType lowerType = services.lower(new EClassifierType(containingEClass), filterType); + for (EClass containingEClass : queryEnvironment.getEPackageProvider() + .getFollowingSiblingsEClasses(receiverEClass)) { + final IType lowerType = services.lower(new EClassifierType(queryEnvironment, + containingEClass), filterType); if (lowerType != null) { - result.add(new SequenceType(lowerType)); + result.add(new SequenceType(queryEnvironment, lowerType)); } } if (result.isEmpty()) { - result.add(new SequenceType(services.nothing("%s can't be a following sibling of %s", - filterType, argTypes.get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing( + "%s can't be a following sibling of %s", filterType, argTypes.get(0)))); } } @@ -603,23 +635,24 @@ public class EObjectServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.get(0).getType() instanceof EClass) { final EClass eCls = (EClass)argTypes.get(0).getType(); if (eCls == EcorePackage.eINSTANCE.getEObject()) { if (argTypes.size() == 1) { - result.add(new SequenceType(argTypes.get(0))); + result.add(new SequenceType(queryEnvironment, argTypes.get(0))); } else if (argTypes.size() == 2) { - result.add(new SequenceType(new EClassifierType(((EClassifierLiteralType)argTypes - .get(1)).getType()))); + result.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + ((EClassifierLiteralType)argTypes.get(1)).getType()))); } } else { - result.addAll(getTypeForSpecificType(services, provider, argTypes, eCls)); + result.addAll(getTypeForSpecificType(services, queryEnvironment, argTypes, eCls)); } } else { - result.add(new SequenceType(services.nothing( + result.add(new SequenceType(queryEnvironment, services.nothing( "Only EClass can have preceding siblings not %s", argTypes.get(0)))); } @@ -632,8 +665,8 @@ public class EObjectServices extends AbstractServiceProvider { * * @param services * the {@link ValidationServices} - * @param provider - * the {@link EPackageProvider} + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param argTypes * arguments {@link IType} * @param receiverEClass @@ -641,29 +674,33 @@ public class EObjectServices extends AbstractServiceProvider { * @return the {@link IType} of elements returned by the service when the receiver type is not the * {@link EObject} {@link EClass} */ - private Set<IType> getTypeForSpecificType(ValidationServices services, EPackageProvider provider, - List<IType> argTypes, final EClass receiverEClass) { + private Set<IType> getTypeForSpecificType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, List<IType> argTypes, final EClass receiverEClass) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.size() == 1) { - for (EClass containingEClass : provider.getPrecedingSiblingsEClasses(receiverEClass)) { - result.add(new SequenceType(new EClassifierType(containingEClass))); + for (EClass containingEClass : queryEnvironment.getEPackageProvider() + .getPrecedingSiblingsEClasses(receiverEClass)) { + result.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + containingEClass))); } if (result.isEmpty()) { - result.add(new SequenceType(services.nothing("%s can't have preceding siblings", argTypes - .get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing( + "%s can't have preceding siblings", argTypes.get(0)))); } } else if (argTypes.size() == 2) { final IType filterType = argTypes.get(1); - for (EClass containingEClass : provider.getPrecedingSiblingsEClasses(receiverEClass)) { - final IType lowerType = services.lower(new EClassifierType(containingEClass), filterType); + for (EClass containingEClass : queryEnvironment.getEPackageProvider() + .getPrecedingSiblingsEClasses(receiverEClass)) { + final IType lowerType = services.lower(new EClassifierType(queryEnvironment, + containingEClass), filterType); if (lowerType != null) { - result.add(new SequenceType(lowerType)); + result.add(new SequenceType(queryEnvironment, lowerType)); } } if (result.isEmpty()) { - result.add(new SequenceType(services.nothing("%s can't be a preceding sibling of %s", - filterType, argTypes.get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing( + "%s can't be a preceding sibling of %s", filterType, argTypes.get(0)))); } } @@ -692,24 +729,25 @@ public class EObjectServices extends AbstractServiceProvider { } @Override - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.get(0).getType() instanceof EClass) { final EClass eCls = (EClass)argTypes.get(0).getType(); if (eCls == EcorePackage.eINSTANCE.getEObject()) { if (argTypes.size() == 1) { - result.add(new SequenceType(argTypes.get(0))); + result.add(new SequenceType(queryEnvironment, argTypes.get(0))); } else if (argTypes.size() == 2) { - result.add(new SequenceType(new EClassifierType(((EClassifierLiteralType)argTypes - .get(1)).getType()))); + result.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + ((EClassifierLiteralType)argTypes.get(1)).getType()))); } } else { - result.addAll(getTypeForSpecificType(services, provider, argTypes, eCls)); + result.addAll(getTypeForSpecificType(services, queryEnvironment, argTypes, eCls)); } } else { - result.add(new SequenceType(services.nothing("Only EClass can have siblings not %s", argTypes - .get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing( + "Only EClass can have siblings not %s", argTypes.get(0)))); } return result; @@ -721,8 +759,8 @@ public class EObjectServices extends AbstractServiceProvider { * * @param services * the {@link ValidationServices} - * @param provider - * the {@link EPackageProvider} + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param argTypes * arguments {@link IType} * @param receiverEClass @@ -730,34 +768,38 @@ public class EObjectServices extends AbstractServiceProvider { * @return the {@link IType} of elements returned by the service when the receiver type is not the * {@link EObject} {@link EClass} */ - private Set<IType> getTypeForSpecificType(ValidationServices services, EPackageProvider provider, - List<IType> argTypes, final EClass receiverEClass) { + private Set<IType> getTypeForSpecificType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, List<IType> argTypes, final EClass receiverEClass) { final Set<IType> result = new LinkedHashSet<IType>(); if (argTypes.size() == 1) { - for (EClass containingEClass : provider.getSiblingsEClasses(receiverEClass)) { - result.add(new SequenceType(new EClassifierType(containingEClass))); + for (EClass containingEClass : queryEnvironment.getEPackageProvider().getSiblingsEClasses( + receiverEClass)) { + result.add(new SequenceType(queryEnvironment, new EClassifierType(queryEnvironment, + containingEClass))); } if (result.isEmpty()) { - result.add(new SequenceType(services.nothing("%s can't have siblings", argTypes.get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing("%s can't have siblings", + argTypes.get(0)))); } } else if (argTypes.size() == 2) { final IType filterType = argTypes.get(1); - for (EClass containingEClass : provider.getSiblingsEClasses(receiverEClass)) { - final IType lowerType = services.lower(new EClassifierType(containingEClass), filterType); + for (EClass containingEClass : queryEnvironment.getEPackageProvider().getSiblingsEClasses( + receiverEClass)) { + final IType lowerType = services.lower(new EClassifierType(queryEnvironment, + containingEClass), filterType); if (lowerType != null) { - result.add(new SequenceType(lowerType)); + result.add(new SequenceType(queryEnvironment, lowerType)); } } if (result.isEmpty()) { - result.add(new SequenceType(services.nothing("%s can't be a sibling of %s", filterType, - argTypes.get(0)))); + result.add(new SequenceType(queryEnvironment, services.nothing( + "%s can't be a sibling of %s", filterType, argTypes.get(0)))); } } return result; } - } /** diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/FilterService.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/FilterService.java index c6200ed9e..0cb8acfe0 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/FilterService.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/FilterService.java @@ -17,7 +17,7 @@ import java.util.Map; import java.util.Map.Entry; import java.util.Set; -import org.eclipse.acceleo.query.runtime.impl.EPackageProvider; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; import org.eclipse.acceleo.query.runtime.impl.ValidationServices; import org.eclipse.acceleo.query.runtime.lookup.basic.Service; import org.eclipse.acceleo.query.validation.type.ICollectionType; @@ -51,15 +51,9 @@ public class FilterService extends Service { super(serviceMethod, serviceInstance); } - /** - * {@inheritDoc} - * - * @see org.eclipse.acceleo.query.runtime.impl.AbstractService#validateAllType(org.eclipse.acceleo.query.runtime.impl.ValidationServices, - * org.eclipse.acceleo.query.runtime.impl.EPackageProvider, java.util.Map) - */ @Override - public Set<IType> validateAllType(ValidationServices services, EPackageProvider provider, - Map<List<IType>, Set<IType>> allTypes) { + public Set<IType> validateAllType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, Map<List<IType>, Set<IType>> allTypes) { final Set<IType> result = new LinkedHashSet<IType>(); final StringBuilder builder = new StringBuilder(); @@ -79,7 +73,7 @@ public class FilterService extends Service { } final IType loweredType = services.lower(filterType, rawType); if (loweredType != null) { - result.add(unrawType(possibleType, loweredType)); + result.add(unrawType(queryEnvironment, possibleType, loweredType)); break; } } @@ -100,9 +94,9 @@ public class FilterService extends Service { final NothingType nothing = services.nothing("Nothing will be left after calling %s:" + builder.toString(), getServiceMethod().getName()); if (List.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SequenceType(nothing)); + result.add(new SequenceType(queryEnvironment, nothing)); } else if (Set.class.isAssignableFrom(getServiceMethod().getReturnType())) { - result.add(new SetType(nothing)); + result.add(new SetType(queryEnvironment, nothing)); } else { result.add(nothing); } @@ -115,6 +109,8 @@ public class FilterService extends Service { * Puts the given raw type into an {@link ICollectionType} or leave it raw according to the given original * {@link IType}. * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param originalType * the original {@link IType} * @param rawType @@ -122,13 +118,13 @@ public class FilterService extends Service { * @return the given raw type into an {@link ICollectionType} or leave it raw according to the given * original {@link IType} */ - private IType unrawType(IType originalType, IType rawType) { + private IType unrawType(IReadOnlyQueryEnvironment queryEnvironment, IType originalType, IType rawType) { final IType result; if (originalType instanceof SequenceType) { - result = new SequenceType(rawType); + result = new SequenceType(queryEnvironment, rawType); } else if (originalType instanceof SetType) { - result = new SetType(rawType); + result = new SetType(queryEnvironment, rawType); } else { result = rawType; } diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/AbstractCollectionType.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/AbstractCollectionType.java index 01bd8c40e..f83759482 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/AbstractCollectionType.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/AbstractCollectionType.java @@ -10,6 +10,8 @@ *******************************************************************************/ package org.eclipse.acceleo.query.validation.type; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; + /** * Abstract collection type implementation. * @@ -25,10 +27,13 @@ public abstract class AbstractCollectionType extends AbstractJavaType implements /** * Constructor. * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param type * the {@link IType} */ - public AbstractCollectionType(IType type) { + public AbstractCollectionType(IReadOnlyQueryEnvironment queryEnvironment, IType type) { + super(queryEnvironment); this.type = type; } diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/AbstractJavaType.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/AbstractJavaType.java index f01508878..23eac0890 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/AbstractJavaType.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/AbstractJavaType.java @@ -10,6 +10,8 @@ *******************************************************************************/ package org.eclipse.acceleo.query.validation.type; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; + /** * Abstract implementation of {@link IJavaType}. * @@ -18,6 +20,21 @@ package org.eclipse.acceleo.query.validation.type; public abstract class AbstractJavaType implements IJavaType { /** + * The {@link IReadOnlyQueryEnvironment}. + */ + private IReadOnlyQueryEnvironment queryEnvironment; + + /** + * Constructor. + * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} + */ + public AbstractJavaType(IReadOnlyQueryEnvironment queryEnvironment) { + this.queryEnvironment = queryEnvironment; + } + + /** * {@inheritDoc} * * @see org.eclipse.acceleo.query.validation.type.IType#isAssignableFrom(org.eclipse.acceleo.query.validation.type.IType) @@ -29,7 +46,8 @@ public abstract class AbstractJavaType implements IJavaType { if (otherType instanceof ClassType) { result = getType().isAssignableFrom(((ClassType)otherType).getType()); } else if (otherType instanceof EClassifierType) { - final Class<?> otherClass = ((EClassifierType)otherType).getType().getInstanceClass(); + final Class<?> otherClass = queryEnvironment.getEPackageProvider().getClass( + ((EClassifierType)otherType).getType()); if (otherClass != null) { result = getType().isAssignableFrom(otherClass); } else { diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/ClassType.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/ClassType.java index abc6dc41f..323963e03 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/ClassType.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/ClassType.java @@ -10,6 +10,8 @@ *******************************************************************************/ package org.eclipse.acceleo.query.validation.type; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; + /** * {@link Class} validation type. * @@ -25,10 +27,13 @@ public class ClassType extends AbstractJavaType implements IJavaType { /** * Constructor. * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param type * the {@link Class} */ - public ClassType(Class<?> type) { + public ClassType(IReadOnlyQueryEnvironment queryEnvironment, Class<?> type) { + super(queryEnvironment); this.type = type; } diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/EClassifierLiteralType.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/EClassifierLiteralType.java index 1ad5810c1..43da9aeac 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/EClassifierLiteralType.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/EClassifierLiteralType.java @@ -10,6 +10,7 @@ *******************************************************************************/ package org.eclipse.acceleo.query.validation.type; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; import org.eclipse.emf.ecore.EClassifier; /** @@ -22,11 +23,13 @@ public class EClassifierLiteralType extends EClassifierType { /** * Constructor. * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param type * the {@link EClassifier} */ - public EClassifierLiteralType(EClassifier type) { - super(type); + public EClassifierLiteralType(IReadOnlyQueryEnvironment queryEnvironment, EClassifier type) { + super(queryEnvironment, type); } /** diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/EClassifierType.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/EClassifierType.java index 505961edf..a7fca5c64 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/EClassifierType.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/EClassifierType.java @@ -10,6 +10,7 @@ *******************************************************************************/ package org.eclipse.acceleo.query.validation.type; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; import org.eclipse.emf.ecore.EClass; import org.eclipse.emf.ecore.EClassifier; import org.eclipse.emf.ecore.EDataType; @@ -27,12 +28,20 @@ public class EClassifierType extends AbstractType { private final EClassifier type; /** + * The {@link IReadOnlyQueryEnvironment}. + */ + private final IReadOnlyQueryEnvironment queryEnvironment; + + /** * Constructor. * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param type * the {@link EClassifier} */ - public EClassifierType(EClassifier type) { + public EClassifierType(IReadOnlyQueryEnvironment queryEnvironment, EClassifier type) { + this.queryEnvironment = queryEnvironment; this.type = type; } @@ -64,7 +73,7 @@ public class EClassifierType extends AbstractType { result = false; } } else if (otherType instanceof IJavaType) { - Class<?> ourClass = getType().getInstanceClass(); + Class<?> ourClass = queryEnvironment.getEPackageProvider().getClass(getType()); if (ourClass != null) { result = ourClass.isAssignableFrom(((IJavaType)otherType).getType()); } else { diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/LambdaType.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/LambdaType.java index 65a511f94..1d60202b8 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/LambdaType.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/LambdaType.java @@ -11,6 +11,7 @@ package org.eclipse.acceleo.query.validation.type; import org.eclipse.acceleo.query.ast.Lambda; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; /** * {@link Lambda} type. @@ -32,12 +33,16 @@ public class LambdaType extends AbstractJavaType implements IJavaType { /** * Constructor. * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param lambdaEvaluatorType * the {@link IType} of this {@link Lambda#getEvaluator() evaluator} type * @param lambdaExpressionType * the {@link IType} of this {@link Lambda#getExpression() expression} type */ - public LambdaType(IType lambdaEvaluatorType, IType lambdaExpressionType) { + public LambdaType(IReadOnlyQueryEnvironment queryEnvironment, IType lambdaEvaluatorType, + IType lambdaExpressionType) { + super(queryEnvironment); this.lambdaEvaluatorType = lambdaEvaluatorType; this.lambdaExpressionType = lambdaExpressionType; } diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/SequenceType.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/SequenceType.java index ed46d471e..fe8d48f1e 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/SequenceType.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/SequenceType.java @@ -12,6 +12,8 @@ package org.eclipse.acceleo.query.validation.type; import java.util.List; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; + /** * Sequence validation type. * @@ -22,11 +24,13 @@ public class SequenceType extends AbstractCollectionType { /** * Constructor. * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param type * the {@link IType} */ - public SequenceType(IType type) { - super(type); + public SequenceType(IReadOnlyQueryEnvironment queryEnvironment, IType type) { + super(queryEnvironment, type); } /** diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/SetType.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/SetType.java index b30bc7a61..0c9f7e46d 100644 --- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/SetType.java +++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/validation/type/SetType.java @@ -12,6 +12,8 @@ package org.eclipse.acceleo.query.validation.type; import java.util.Set; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; + /** * Set validation type. * @@ -22,11 +24,13 @@ public class SetType extends AbstractCollectionType { /** * Constructor. * + * @param queryEnvironment + * the {@link IReadOnlyQueryEnvironment} * @param type * the {@link IType} */ - public SetType(IType type) { - super(type); + public SetType(IReadOnlyQueryEnvironment queryEnvironment, IType type) { + super(queryEnvironment, type); } /** diff --git a/query/tests/org.eclipse.acceleo.query.ide.ui.tests/src/org/eclipse/acceleo/query/ide/ui/test/ProposalLabelProviderTests.java b/query/tests/org.eclipse.acceleo.query.ide.ui.tests/src/org/eclipse/acceleo/query/ide/ui/test/ProposalLabelProviderTests.java index 945a71bc0..053f5c7c4 100644 --- a/query/tests/org.eclipse.acceleo.query.ide.ui.tests/src/org/eclipse/acceleo/query/ide/ui/test/ProposalLabelProviderTests.java +++ b/query/tests/org.eclipse.acceleo.query.ide.ui.tests/src/org/eclipse/acceleo/query/ide/ui/test/ProposalLabelProviderTests.java @@ -19,8 +19,8 @@ import java.util.Set; import org.eclipse.acceleo.query.ide.ui.ProposalLabelProvider; import org.eclipse.acceleo.query.runtime.ICompletionProposal; +import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment; import org.eclipse.acceleo.query.runtime.IService; -import org.eclipse.acceleo.query.runtime.impl.EPackageProvider; import org.eclipse.acceleo.query.runtime.impl.ValidationServices; import org.eclipse.acceleo.query.runtime.impl.completion.EClassifierCompletionProposal; import org.eclipse.acceleo.query.runtime.impl.completion.EEnumLiteralCompletionProposal; @@ -56,12 +56,14 @@ public class ProposalLabelProviderTests { /** * {@inheritDoc} * - * @see org.eclipse.acceleo.query.runtime.IService#getType(ValidationServices, EPackageProvider, List) + * @see org.eclipse.acceleo.query.runtime.IService#getType(org.eclipse.acceleo.query.runtime.impl.ValidationServices, + * org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment, java.util.List) */ - public Set<IType> getType(ValidationServices services, EPackageProvider provider, List<IType> argTypes) { + public Set<IType> getType(ValidationServices services, IReadOnlyQueryEnvironment queryEnvironment, + List<IType> argTypes) { final Set<IType> result = new LinkedHashSet<IType>(); - result.add(new ClassType(String.class)); + result.add(new ClassType(queryEnvironment, String.class)); return result; } @@ -70,10 +72,10 @@ public class ProposalLabelProviderTests { * {@inheritDoc} * * @see org.eclipse.acceleo.query.runtime.IService#validateAllType(org.eclipse.acceleo.query.runtime.impl.ValidationServices, - * org.eclipse.acceleo.query.runtime.impl.EPackageProvider, java.util.Map) + * org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment, java.util.Map) */ - public Set<IType> validateAllType(ValidationServices services, EPackageProvider provider, - Map<List<IType>, Set<IType>> allTypes) { + public Set<IType> validateAllType(ValidationServices services, + IReadOnlyQueryEnvironment queryEnvironment, Map<List<IType>, Set<IType>> allTypes) { final Set<IType> result = new LinkedHashSet<IType>(); for (Entry<List<IType>, Set<IType>> entry : allTypes.entrySet()) { diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java index e90899f0e..8b127cf91 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java @@ -58,10 +58,10 @@ public class CompletionTest { variableTypes.clear(); final Set<IType> selfTypes = new LinkedHashSet<IType>(); - selfTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEClass())); + selfTypes.add(new EClassifierType(queryEnvironment, EcorePackage.eINSTANCE.getEClass())); variableTypes.put("self", selfTypes); final Set<IType> stuffTypes = new LinkedHashSet<IType>(); - stuffTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); + stuffTypes.add(new EClassifierType(queryEnvironment, EcorePackage.eINSTANCE.getEPackage())); variableTypes.put("stuff", stuffTypes); } @@ -149,7 +149,7 @@ public class CompletionTest { @Test public void someIntTest() { final Set<IType> someIntTypes = new LinkedHashSet<IType>(); - someIntTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEInt())); + someIntTypes.add(new EClassifierType(queryEnvironment, EcorePackage.eINSTANCE.getEInt())); variableTypes.put("someInt", someIntTypes); final ICompletionResult completionResult = engine.getCompletion("someInt ", 8, variableTypes); @@ -165,7 +165,7 @@ public class CompletionTest { @Test public void alfMultTest() { final Set<IType> someIntTypes = new LinkedHashSet<IType>(); - someIntTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEInt())); + someIntTypes.add(new EClassifierType(queryEnvironment, EcorePackage.eINSTANCE.getEInt())); variableTypes.put("someInt", someIntTypes); final ICompletionResult completionResult = engine.getCompletion("someInt * ", 10, variableTypes); @@ -334,7 +334,7 @@ public class CompletionTest { } else if (prop instanceof ServiceCompletionProposal) { final Class<?> cls; if (type instanceof EClass) { - cls = ((EClass)type).getInstanceClass(); + cls = queryEnvironment.getEPackageProvider().getClass((EClass)type); } else { cls = (Class<?>)type; } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationTest.java index 8b063c37d..53ab8c56c 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationTest.java @@ -59,10 +59,10 @@ public class ValidationTest { variableTypes.clear(); final Set<IType> selfTypes = new LinkedHashSet<IType>(); - selfTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEClass())); + selfTypes.add(new EClassifierType(queryEnvironment, EcorePackage.eINSTANCE.getEClass())); variableTypes.put("self", selfTypes); final Set<IType> stuffTypes = new LinkedHashSet<IType>(); - stuffTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); + stuffTypes.add(new EClassifierType(queryEnvironment, EcorePackage.eINSTANCE.getEPackage())); variableTypes.put("stuff", stuffTypes); } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/AbtractServiceLookupTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/AbtractServiceLookupTest.java index e9112c23b..5ab9df574 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/AbtractServiceLookupTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/AbtractServiceLookupTest.java @@ -10,8 +10,8 @@ *******************************************************************************/ package org.eclipse.acceleo.query.runtime.servicelookup; +import org.eclipse.acceleo.query.runtime.ILookupEngine; import org.eclipse.acceleo.query.runtime.IService; -import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine; import org.junit.Test; import static org.junit.Assert.assertEquals; @@ -22,14 +22,14 @@ public abstract class AbtractServiceLookupTest { private static final Class<?>[] NO_ARG = {}; - abstract BasicLookupEngine getEngine(); + abstract ILookupEngine getEngine(); /** * Tests that the empty engine behaves as expected (returns null to any lookup). */ @Test public void emptyEngineTest() { - BasicLookupEngine engine = getEngine(); + ILookupEngine engine = getEngine(); assertNull(engine.lookup("method", NO_ARG)); assertNull(engine.lookup("method", new Class<?>[] {Object.class, Integer.class })); } @@ -40,7 +40,7 @@ public abstract class AbtractServiceLookupTest { */ @Test public void leafTest() { - BasicLookupEngine engine = getEngine(); + ILookupEngine engine = getEngine(); assertEquals("service0", engine.lookup("service0", NO_ARG).getServiceMethod().getName()); assertEquals("service1", engine.lookup("service1", NO_ARG).getServiceMethod().getName()); assertEquals("service2", engine.lookup("service2", NO_ARG).getServiceMethod().getName()); @@ -53,7 +53,7 @@ public abstract class AbtractServiceLookupTest { */ @Test public void oneArgSingleMethodSameClassTest() { - BasicLookupEngine engine = getEngine(); + ILookupEngine engine = getEngine(); assertEquals("service3", engine.lookup("service3", new Class<?>[] {Object.class }).getServiceMethod() .getName()); @@ -65,7 +65,7 @@ public abstract class AbtractServiceLookupTest { */ @Test public void nullValueSingleMethodSameClassTest() { - BasicLookupEngine engine = getEngine(); + ILookupEngine engine = getEngine(); /* * We should not fail if there is no ambiguity regarding which method we have to call, even if we * don't have type information regarding arguments. @@ -81,7 +81,7 @@ public abstract class AbtractServiceLookupTest { */ @Test public void oneArgSingleMethodSubClassTest() { - BasicLookupEngine engine = getEngine(); + ILookupEngine engine = getEngine(); assertEquals("service3", engine.lookup("service3", new Class<?>[] {Integer.class }) .getServiceMethod().getName()); } @@ -91,7 +91,7 @@ public abstract class AbtractServiceLookupTest { */ @Test public void oneArgMultiMethodSameClassTest() { - BasicLookupEngine engine = getEngine(); + ILookupEngine engine = getEngine(); IService service = engine.lookup("service4", new Class<?>[] {Integer.class }); assertEquals("service4", service.getServiceMethod().getName()); assertEquals(1, service.getServiceMethod().getParameterTypes().length); @@ -111,7 +111,7 @@ public abstract class AbtractServiceLookupTest { */ @Test public void oneArgMultiMethodSubClassTest() { - BasicLookupEngine engine = getEngine(); + ILookupEngine engine = getEngine(); IService service = engine.lookup("service4", new Class<?>[] {Integer.class }); assertEquals("service4", service.getServiceMethod().getName()); assertEquals(1, service.getServiceMethod().getParameterTypes().length); diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupCrossReferencerTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupCrossReferencerTest.java index 65370abd7..fd313d596 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupCrossReferencerTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupCrossReferencerTest.java @@ -12,9 +12,9 @@ package org.eclipse.acceleo.query.runtime.servicelookup; import java.util.logging.Logger; +import org.eclipse.acceleo.query.runtime.ILookupEngine; import org.eclipse.acceleo.query.runtime.IQueryEnvironment; import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException; -import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine; import org.eclipse.acceleo.query.services.tests.AbstractEngineInitializationWithCrossReferencer; import org.eclipse.emf.ecore.EClass; import org.eclipse.emf.ecore.EcoreFactory; @@ -26,7 +26,7 @@ import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; public class BasicLookupCrossReferencerTest extends AbstractEngineInitializationWithCrossReferencer { - BasicLookupEngine engine; + ILookupEngine engine; private static final Class<?>[] NO_ARG = {}; @@ -38,7 +38,7 @@ public class BasicLookupCrossReferencerTest extends AbstractEngineInitialization IQueryEnvironment queryEnvironment = getQueryEnvironnementWithCrossReferencer(eClass, logger); engine = queryEnvironment.getLookupEngine(); try { - engine.addServices(CrossReferencerClass.class); + queryEnvironment.registerServicePackage(CrossReferencerClass.class); } catch (InvalidAcceleoPackageException e) { throw new UnsupportedOperationException("shouldn't happen.", e); } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupTest.java index 6dd13b9cd..5cc6f99cd 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupTest.java @@ -10,19 +10,19 @@ *******************************************************************************/ package org.eclipse.acceleo.query.runtime.servicelookup; +import org.eclipse.acceleo.query.runtime.ILookupEngine; import org.eclipse.acceleo.query.runtime.IQueryEnvironment; import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException; import org.eclipse.acceleo.query.runtime.impl.QueryEnvironment; -import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine; public class BasicLookupTest extends AbtractServiceLookupTest { @Override - BasicLookupEngine getEngine() { + ILookupEngine getEngine() { IQueryEnvironment queryEnvironment = new QueryEnvironment(null); - BasicLookupEngine engine = queryEnvironment.getLookupEngine(); + ILookupEngine engine = queryEnvironment.getLookupEngine(); try { - engine.addServices(ServicesClass.class); + queryEnvironment.registerServicePackage(ServicesClass.class); } catch (InvalidAcceleoPackageException e) { throw new UnsupportedOperationException("shouldn't happen.", e); } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServicesTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServicesTest.java index 0f48e0390..9ed087b41 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServicesTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServicesTest.java @@ -28,10 +28,10 @@ import java.util.Map.Entry; import java.util.Set; import org.eclipse.acceleo.query.runtime.AcceleoQueryEvaluationException; +import org.eclipse.acceleo.query.runtime.ILookupEngine; import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException; import org.eclipse.acceleo.query.runtime.impl.EvaluationServices; import org.eclipse.acceleo.query.runtime.impl.QueryEnvironment; -import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine; import org.eclipse.acceleo.query.tests.Setup; import org.eclipse.emf.common.util.EList; import org.eclipse.emf.common.util.URI; @@ -63,7 +63,7 @@ public class EvaluationServicesTest { QueryEnvironment queryEnvironment; - BasicLookupEngine engine; + ILookupEngine engine; EvaluationServices services; diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AbstractServicesTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AbstractServicesTest.java index 448ed9dc5..167f365b4 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AbstractServicesTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AbstractServicesTest.java @@ -11,12 +11,15 @@ package org.eclipse.acceleo.query.services.tests; import java.lang.reflect.InvocationTargetException; +import java.util.LinkedHashSet; +import java.util.Set; +import org.eclipse.acceleo.query.runtime.ILookupEngine; import org.eclipse.acceleo.query.runtime.IQueryEnvironment; import org.eclipse.acceleo.query.runtime.IService; import org.eclipse.acceleo.query.runtime.impl.QueryEnvironment; import org.eclipse.acceleo.query.runtime.impl.ValidationServices; -import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine; +import org.eclipse.acceleo.query.validation.type.IType; import org.junit.Before; import static org.junit.Assert.assertEquals; @@ -24,7 +27,7 @@ import static org.junit.Assert.assertTrue; public abstract class AbstractServicesTest { - private BasicLookupEngine lookupEngine; + private ILookupEngine lookupEngine; private IQueryEnvironment queryEnvironment; @@ -37,7 +40,7 @@ public abstract class AbstractServicesTest { validationServices = new ValidationServices(queryEnvironment, true); } - public BasicLookupEngine getLookupEngine() { + public ILookupEngine getLookupEngine() { return lookupEngine; } @@ -58,6 +61,23 @@ public abstract class AbstractServicesTest { } /** + * Creates a {@link Set} of {@link IType} with the given {@link IType}. + * + * @param types + * {@link IType} + * @return a new {@link Set} of {@link IType} with the given {@link IType} + */ + protected Set<IType> createTypeSet(IType... types) { + final Set<IType> result = new LinkedHashSet<IType>(); + + for (IType type : types) { + result.add(type); + } + + return result; + } + + /** * Looks up for a service according to the given name and arguments. * * @param serviceName @@ -74,4 +94,5 @@ public abstract class AbstractServicesTest { IService service = lookupEngine.lookup(serviceName, argTypes); return service; } + } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesTest.java index a55519fb9..aa5ec8274 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesTest.java @@ -50,8 +50,8 @@ public class AnyServicesTest extends AbstractServicesTest { @Override public void before() throws Exception { super.before(); - getLookupEngine().addServices(AnyServices.class); - any = new AnyServices(); + getQueryEnvironment().registerServicePackage(AnyServices.class); + any = new AnyServices(getQueryEnvironment()); this.reverseModel = new UnitTestModels(Setup.createSetupForCurrentEnvironment()).reverse(); } @@ -461,17 +461,36 @@ public class AnyServicesTest extends AbstractServicesTest { assertFalse(any.oclIsTypeOf(Color.BLACK, AnydslPackage.Literals.CALIBER)); } + @Test(expected = java.lang.IllegalArgumentException.class) + public void testOCLIsTypeOfEDataTypeNotRegistered() { + any.oclIsTypeOf("a string", AnydslPackage.Literals.SINGLE_STRING); + } + @Test public void testOCLIsTypeOfEDataType() { - assertTrue(any.oclIsTypeOf("a string", AnydslPackage.Literals.SINGLE_STRING)); - assertFalse(any.oclIsTypeOf(new Integer(1), AnydslPackage.Literals.SINGLE_STRING)); + try { + getQueryEnvironment().registerEPackage(AnydslPackage.eINSTANCE); + assertTrue(any.oclIsTypeOf("a string", AnydslPackage.Literals.SINGLE_STRING)); + assertFalse(any.oclIsTypeOf(new Integer(1), AnydslPackage.Literals.SINGLE_STRING)); + } finally { + getQueryEnvironment().removeEPackage(AnydslPackage.eINSTANCE.getNsPrefix()); + } + } + @Test(expected = java.lang.IllegalArgumentException.class) + public void testOCLIsKindOfEDataTypeNotRegistered() { + any.oclIsKindOf("a string", AnydslPackage.Literals.SINGLE_STRING); } @Test public void testOCLIsKindOfEDataType() { - assertTrue(any.oclIsKindOf("a string", AnydslPackage.Literals.SINGLE_STRING)); - assertFalse(any.oclIsKindOf(new Integer(1), AnydslPackage.Literals.SINGLE_STRING)); + try { + getQueryEnvironment().registerEPackage(AnydslPackage.eINSTANCE); + assertTrue(any.oclIsKindOf("a string", AnydslPackage.Literals.SINGLE_STRING)); + assertFalse(any.oclIsKindOf(new Integer(1), AnydslPackage.Literals.SINGLE_STRING)); + } finally { + getQueryEnvironment().removeEPackage(AnydslPackage.eINSTANCE.getNsPrefix()); + } } /** diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesValidationTest.java index ad91a5249..3094a5018 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesValidationTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesValidationTest.java @@ -32,7 +32,7 @@ public class AnyServicesValidationTest extends AbstractServicesTest { @Override public void before() throws Exception { super.before(); - getLookupEngine().addServices(AnyServices.class); + getQueryEnvironment().registerServicePackage(AnyServices.class); } @Test @@ -40,14 +40,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("equals", new Boolean[] {true, true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -55,14 +54,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("equals", new Boolean[] {Boolean.TRUE, Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -70,14 +68,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("differs", new Boolean[] {true, true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -85,14 +82,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("differs", new Boolean[] {Boolean.TRUE, Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -100,14 +96,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("lessThan", new Boolean[] {true, true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -115,14 +110,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("lessThan", new Boolean[] {Boolean.TRUE, Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -130,14 +124,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("greaterThan", new Boolean[] {true, true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -145,14 +138,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("greaterThan", new Boolean[] {Boolean.TRUE, Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -160,14 +152,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("lessThanEqual", new Boolean[] {true, true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -175,14 +166,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("lessThanEqual", new Boolean[] {Boolean.TRUE, Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -190,14 +180,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("greaterThanEqual", new Boolean[] {true, true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -206,14 +195,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { new Boolean[] {Boolean.TRUE, Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -221,14 +209,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("add", new Object[] {true, "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -236,14 +223,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("add", new Object[] {Boolean.TRUE, "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -251,14 +237,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("add", new Object[] {"", true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -266,14 +251,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("add", new Object[] {"", Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -281,14 +265,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("oclIsKindOf", new Object[] {new Object(), int.class }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Object.class)); - argTypes.add(new ClassType(Class.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Object.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Class.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -296,14 +279,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("oclIsKindOf", new Object[] {new Object(), Integer.class }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Object.class)); - argTypes.add(new ClassType(Class.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Object.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Class.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -312,14 +294,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Object.class)); - argTypes.add(new ClassType(EClass.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Object.class)); + argTypes.add(new ClassType(getQueryEnvironment(), EClass.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -327,14 +308,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("oclIsTypeOf", new Object[] {new Object(), int.class }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Object.class)); - argTypes.add(new ClassType(Class.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Object.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Class.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -342,14 +322,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("oclIsTypeOf", new Object[] {new Object(), Integer.class }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Object.class)); - argTypes.add(new ClassType(Class.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Object.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Class.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -358,14 +337,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Object.class)); - argTypes.add(new ClassType(EClass.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Object.class)); + argTypes.add(new ClassType(getQueryEnvironment(), EClass.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -373,14 +351,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("oclAsType", new Object[] {new Object(), int.class }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Object.class)); - argTypes.add(new ClassType(int.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Object.class)); + argTypes.add(new ClassType(getQueryEnvironment(), int.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(int.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), int.class), it.next()); } @Test @@ -388,14 +365,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("oclAsType", new Object[] {new Object(), Integer.class }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Object.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Object.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -404,14 +380,13 @@ public class AnyServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Object.class)); - argTypes.add(new ClassType(EClass.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Object.class)); + argTypes.add(new ClassType(getQueryEnvironment(), EClass.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(EClass.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), EClass.class), it.next()); } @Test @@ -420,14 +395,14 @@ public class AnyServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Object.class)); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new ClassType(getQueryEnvironment(), Object.class)); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new EClassifierType(EcorePackage.eINSTANCE.getEClass()), it.next()); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass()), it + .next()); } @Test @@ -435,13 +410,12 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("toString", new Boolean[] {true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -449,13 +423,12 @@ public class AnyServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("toString", new Boolean[] {Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesTest.java index 8b730ec55..0b862845d 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesTest.java @@ -20,7 +20,7 @@ public class BooleanServicesTest extends AbstractServicesTest { @Override public void before() throws Exception { super.before(); - getLookupEngine().addServices(BooleanServices.class); + getQueryEnvironment().registerServicePackage(BooleanServices.class); } @Test(expected = java.lang.NullPointerException.class) diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesValidationTest.java index 1b4a6074f..bc87deb82 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesValidationTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesValidationTest.java @@ -29,7 +29,7 @@ public class BooleanServicesValidationTest extends AbstractServicesTest { @Override public void before() throws Exception { super.before(); - getLookupEngine().addServices(BooleanServices.class); + getQueryEnvironment().registerServicePackage(BooleanServices.class); } @Test @@ -37,14 +37,13 @@ public class BooleanServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("or", new Boolean[] {true, true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -52,14 +51,13 @@ public class BooleanServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("or", new Boolean[] {Boolean.TRUE, Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -67,14 +65,13 @@ public class BooleanServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("and", new Boolean[] {true, true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -82,14 +79,13 @@ public class BooleanServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("and", new Boolean[] {Boolean.TRUE, Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -97,13 +93,12 @@ public class BooleanServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("not", new Boolean[] {true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -111,13 +106,12 @@ public class BooleanServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("not", new Boolean[] {Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -125,14 +119,13 @@ public class BooleanServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("implies", new Boolean[] {true, true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -140,14 +133,13 @@ public class BooleanServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("implies", new Boolean[] {Boolean.TRUE, Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -155,14 +147,13 @@ public class BooleanServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("xor", new Boolean[] {true, true }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(boolean.class)); - argTypes.add(new ClassType(boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -170,14 +161,13 @@ public class BooleanServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("xor", new Boolean[] {Boolean.TRUE, Boolean.TRUE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Boolean.class)); - argTypes.add(new ClassType(Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Boolean.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/CollectionServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/CollectionServicesValidationTest.java index 41648baff..774d4edc9 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/CollectionServicesValidationTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/CollectionServicesValidationTest.java @@ -44,7 +44,7 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { @Override public void before() throws Exception { super.before(); - getLookupEngine().addServices(CollectionServices.class); + getQueryEnvironment().registerServicePackage(CollectionServices.class); } @Test @@ -54,23 +54,25 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); final NothingType nothingType = new NothingType("Empty"); - argTypes.add(new SequenceType(nothingType)); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), nothingType)); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(nothingType), it.next()); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), nothingType), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); final Map<List<IType>, Set<IType>> allTypes = new LinkedHashMap<List<IType>, Set<IType>>(); allTypes.put(argTypes, types); final Set<IType> validatedTypes = service.validateAllType(getValidationServices(), - getQueryEnvironment().getEPackageProvider(), allTypes); + getQueryEnvironment(), allTypes); assertEquals(1, validatedTypes.size()); it = validatedTypes.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); } @Test @@ -80,23 +82,25 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); final NothingType nothingType = new NothingType("Empty"); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new SequenceType(nothingType)); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), nothingType)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); - assertEquals(new SequenceType(nothingType), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), nothingType), it.next()); final Map<List<IType>, Set<IType>> allTypes = new LinkedHashMap<List<IType>, Set<IType>>(); allTypes.put(argTypes, types); final Set<IType> validatedTypes = service.validateAllType(getValidationServices(), - getQueryEnvironment().getEPackageProvider(), allTypes); + getQueryEnvironment(), allTypes); assertEquals(1, validatedTypes.size()); it = validatedTypes.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); } @Test @@ -105,15 +109,18 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new ArrayList<Integer>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new SequenceType(new ClassType(Integer.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); - assertEquals(new SequenceType(new ClassType(Integer.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class)), it.next()); } @Test @@ -123,23 +130,24 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); final NothingType nothingType = new NothingType("Empty"); - argTypes.add(new SetType(nothingType)); - argTypes.add(new SetType(new ClassType(String.class))); + argTypes.add(new SetType(getQueryEnvironment(), nothingType)); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(nothingType), it.next()); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), nothingType), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); final Map<List<IType>, Set<IType>> allTypes = new LinkedHashMap<List<IType>, Set<IType>>(); allTypes.put(argTypes, types); final Set<IType> validatedTypes = service.validateAllType(getValidationServices(), - getQueryEnvironment().getEPackageProvider(), allTypes); + getQueryEnvironment(), allTypes); assertEquals(1, validatedTypes.size()); it = validatedTypes.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); } @Test @@ -149,23 +157,24 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); final NothingType nothingType = new NothingType("Empty"); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new SetType(nothingType)); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new SetType(getQueryEnvironment(), nothingType)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); - assertEquals(new SetType(nothingType), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); + assertEquals(new SetType(getQueryEnvironment(), nothingType), it.next()); final Map<List<IType>, Set<IType>> allTypes = new LinkedHashMap<List<IType>, Set<IType>>(); allTypes.put(argTypes, types); final Set<IType> validatedTypes = service.validateAllType(getValidationServices(), - getQueryEnvironment().getEPackageProvider(), allTypes); + getQueryEnvironment(), allTypes); assertEquals(1, validatedTypes.size()); it = validatedTypes.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); } @Test @@ -174,15 +183,16 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new LinkedHashSet<Integer>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new SetType(new ClassType(Integer.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); - assertEquals(new SetType(new ClassType(Integer.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), Integer.class)), + it.next()); } @Test @@ -191,11 +201,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("any", new Object[] {new ArrayList<String>(), lambda }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new ClassType(Integer.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class), new ClassType(getQueryEnvironment(), + Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -205,36 +217,50 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { @Test public void testAnySet() { - final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); - final IService service = serviceLookUp("any", new Object[] {new LinkedHashSet<String>(), lambda }); - assertTrue(service != null); - final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new EClassifierType(EcorePackage.eINSTANCE - .getEBoolean()))); - - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); - assertEquals(1, types.size()); - Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + try { + getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); + final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); + final IService service = serviceLookUp("any", new Object[] {new LinkedHashSet<String>(), lambda }); + assertTrue(service != null); + final List<IType> argTypes = new ArrayList<IType>(); + argTypes.add(new SetType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class), new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEBoolean()))); + + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); + assertEquals(1, types.size()); + Iterator<IType> it = types.iterator(); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); + } finally { + getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); + } } @Test public void testAnyList() { - final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); - final IService service = serviceLookUp("any", new Object[] {new ArrayList<String>(), lambda }); - assertTrue(service != null); - final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new EClassifierType(EcorePackage.eINSTANCE - .getEBoolean()))); - - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); - assertEquals(1, types.size()); - Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + try { + getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); + final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); + final IService service = serviceLookUp("any", new Object[] {new ArrayList<String>(), lambda }); + assertTrue(service != null); + final List<IType> argTypes = new ArrayList<IType>(); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class), new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEBoolean()))); + + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); + assertEquals(1, types.size()); + Iterator<IType> it = types.iterator(); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); + } finally { + getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); + } } @Test @@ -242,13 +268,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("asOrderedSet", new Object[] {new LinkedHashSet<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); } @Test @@ -256,13 +282,14 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("asOrderedSet", new Object[] {new ArrayList<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); } @Test @@ -270,13 +297,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("asSequence", new Object[] {new LinkedHashSet<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); } @Test @@ -284,13 +311,14 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("asSequence", new Object[] {new ArrayList<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); } @Test @@ -298,13 +326,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("asSet", new Object[] {new LinkedHashSet<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); } @Test @@ -312,13 +340,14 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("asSet", new Object[] {new ArrayList<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); } @Test @@ -327,13 +356,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -342,14 +371,16 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("collect", new Object[] {new LinkedHashSet<String>(), lambda }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new ClassType(Integer.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class), new ClassType(getQueryEnvironment(), + Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(Integer.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), Integer.class)), + it.next()); } @Test @@ -358,14 +389,17 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("collect", new Object[] {new ArrayList<String>(), lambda }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new ClassType(Integer.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class), new ClassType(getQueryEnvironment(), + Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(Integer.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class)), it.next()); } @Test @@ -374,15 +408,18 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new ArrayList<Integer>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new SequenceType(new ClassType(Integer.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); - assertEquals(new SequenceType(new ClassType(Integer.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class)), it.next()); } @Test @@ -391,13 +428,12 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -406,13 +442,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -421,13 +457,12 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -436,13 +471,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -451,13 +486,12 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -466,13 +500,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -481,15 +515,17 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); - assertEquals(new SequenceType(new ClassType(Integer.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class)), it.next()); } @Test @@ -498,15 +534,16 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); - assertEquals(new SetType(new ClassType(Integer.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), Integer.class)), + it.next()); } @Test @@ -515,14 +552,14 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -531,16 +568,18 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); - assertEquals(new SequenceType(new ClassType(Double.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Double.class)), it.next()); } @Test @@ -562,11 +601,11 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new LinkedHashSet<Integer>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new EClassifierType(eCls1))); - argTypes.add(new SetType(new EClassifierType(eCls2))); + argTypes.add(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), eCls1))); + argTypes.add(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), eCls2))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -610,11 +649,11 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new LinkedHashSet<Integer>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new EClassifierType(eCls1))); - argTypes.add(new SetType(new EClassifierType(eCls2))); + argTypes.add(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), eCls1))); + argTypes.add(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), eCls2))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -632,14 +671,14 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new LinkedHashSet<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new SetType(new ClassType(String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); } @Test @@ -648,14 +687,15 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new LinkedHashSet<EClassifier>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(EClass.class))); - argTypes.add(new SetType(new ClassType(EClassifier.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), EClass.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + EClassifier.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(EClass.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), EClass.class)), + it.next()); } @Test @@ -664,14 +704,15 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new LinkedHashSet<EClassifier>(), new LinkedHashSet<EClass>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(EClassifier.class))); - argTypes.add(new SetType(new ClassType(EClass.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + EClassifier.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), EClass.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(EClass.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), EClass.class)), + it.next()); } @Test @@ -679,13 +720,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("isEmpty", new Object[] {new ArrayList<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -693,13 +734,12 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("isEmpty", new Object[] {new LinkedHashSet<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -709,15 +749,15 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new Object[] {new LinkedHashSet<String>(), lambda }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new EClassifierType(EcorePackage.eINSTANCE - .getEClass()))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class), new EClassifierType( + getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass()))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -726,15 +766,16 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("isUnique", new Object[] {new ArrayList<String>(), lambda }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new EClassifierType(EcorePackage.eINSTANCE - .getEClass()))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class), new EClassifierType( + getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass()))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -742,13 +783,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("last", new Object[] {new ArrayList<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -756,13 +797,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("notEmpty", new Object[] {new ArrayList<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -770,13 +811,12 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("notEmpty", new Object[] {new LinkedHashSet<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -785,11 +825,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("one", new Object[] {new ArrayList<String>(), lambda }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new ClassType(Integer.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class), new ClassType(getQueryEnvironment(), + Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -799,36 +841,52 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { @Test public void testOneSet() { - final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); - final IService service = serviceLookUp("one", new Object[] {new LinkedHashSet<String>(), lambda }); - assertTrue(service != null); - final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new EClassifierType(EcorePackage.eINSTANCE - .getEBoolean()))); - - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); - assertEquals(1, types.size()); - Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + try { + getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); + final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); + final IService service = serviceLookUp("one", new Object[] {new LinkedHashSet<String>(), lambda }); + assertTrue(service != null); + final List<IType> argTypes = new ArrayList<IType>(); + argTypes.add(new SetType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class), new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEBoolean()))); + + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); + assertEquals(1, types.size()); + Iterator<IType> it = types.iterator(); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEBooleanObject()), it.next()); + } finally { + getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); + } } @Test public void testOneList() { - final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); - final IService service = serviceLookUp("one", new Object[] {new ArrayList<String>(), lambda }); - assertTrue(service != null); - final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new EClassifierType(EcorePackage.eINSTANCE - .getEBoolean()))); - - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); - assertEquals(1, types.size()); - Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + try { + getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); + final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); + final IService service = serviceLookUp("one", new Object[] {new ArrayList<String>(), lambda }); + assertTrue(service != null); + final List<IType> argTypes = new ArrayList<IType>(); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class), new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEBoolean()))); + + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); + assertEquals(1, types.size()); + Iterator<IType> it = types.iterator(); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEBooleanObject()), it.next()); + } finally { + getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); + } } @Test @@ -837,15 +895,17 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); - assertEquals(new SequenceType(new ClassType(Integer.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class)), it.next()); } @Test @@ -854,11 +914,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("reject", new Object[] {new ArrayList<String>(), lambda }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new ClassType(Integer.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class), new ClassType(getQueryEnvironment(), + Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -868,36 +930,53 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { @Test public void testRejectSet() { - final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); - final IService service = serviceLookUp("reject", new Object[] {new LinkedHashSet<String>(), lambda }); - assertTrue(service != null); - final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new EClassifierType(EcorePackage.eINSTANCE - .getEBoolean()))); - - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); - assertEquals(1, types.size()); - Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + try { + getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); + final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); + final IService service = serviceLookUp("reject", new Object[] {new LinkedHashSet<String>(), + lambda }); + assertTrue(service != null); + final List<IType> argTypes = new ArrayList<IType>(); + argTypes.add(new SetType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class), new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEBoolean()))); + + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); + assertEquals(1, types.size()); + Iterator<IType> it = types.iterator(); + assertEquals(new SetType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class)), it.next()); + } finally { + getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); + } } @Test public void testRejectList() { - final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); - final IService service = serviceLookUp("reject", new Object[] {new ArrayList<String>(), lambda }); - assertTrue(service != null); - final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new EClassifierType(EcorePackage.eINSTANCE - .getEBoolean()))); - - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); - assertEquals(1, types.size()); - Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); + try { + getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); + final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); + final IService service = serviceLookUp("reject", new Object[] {new ArrayList<String>(), lambda }); + assertTrue(service != null); + final List<IType> argTypes = new ArrayList<IType>(); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class), new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEBoolean()))); + + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); + assertEquals(1, types.size()); + Iterator<IType> it = types.iterator(); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + } finally { + getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); + } } @Test @@ -906,11 +985,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("select", new Object[] {new ArrayList<String>(), lambda }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new ClassType(Integer.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class), new ClassType(getQueryEnvironment(), + Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -920,36 +1001,53 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { @Test public void testSelectSet() { - final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); - final IService service = serviceLookUp("select", new Object[] {new LinkedHashSet<String>(), lambda }); - assertTrue(service != null); - final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new EClassifierType(EcorePackage.eINSTANCE - .getEBoolean()))); - - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); - assertEquals(1, types.size()); - Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + try { + getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); + final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); + final IService service = serviceLookUp("select", new Object[] {new LinkedHashSet<String>(), + lambda }); + assertTrue(service != null); + final List<IType> argTypes = new ArrayList<IType>(); + argTypes.add(new SetType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class), new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEBoolean()))); + + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); + assertEquals(1, types.size()); + Iterator<IType> it = types.iterator(); + assertEquals(new SetType(getQueryEnvironment(), + new ClassType(getQueryEnvironment(), String.class)), it.next()); + } finally { + getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); + } } @Test public void testSelectList() { - final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); - final IService service = serviceLookUp("select", new Object[] {new ArrayList<String>(), lambda }); - assertTrue(service != null); - final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new LambdaType(new ClassType(String.class), new EClassifierType(EcorePackage.eINSTANCE - .getEBoolean()))); - - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); - assertEquals(1, types.size()); - Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); + try { + getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); + final Lambda lambda = AstPackage.eINSTANCE.getAstFactory().createLambda(); + final IService service = serviceLookUp("select", new Object[] {new ArrayList<String>(), lambda }); + assertTrue(service != null); + final List<IType> argTypes = new ArrayList<IType>(); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new LambdaType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class), new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEBoolean()))); + + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); + assertEquals(1, types.size()); + Iterator<IType> it = types.iterator(); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + } finally { + getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); + } } @Test @@ -958,15 +1056,17 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); - assertEquals(new SequenceType(new ClassType(Integer.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class)), it.next()); } @Test @@ -975,15 +1075,16 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); - assertEquals(new SequenceType(new ClassType(Integer.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class)), it.next()); } @Test @@ -992,17 +1093,19 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0), "", Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(3, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); - assertEquals(new SequenceType(new ClassType(Integer.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class)), it.next()); } @Test @@ -1011,17 +1114,18 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0), "", Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(3, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); - assertEquals(new SequenceType(new ClassType(Integer.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class)), it.next()); } @Test @@ -1029,13 +1133,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("size", new Object[] {new ArrayList<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -1043,13 +1147,12 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("size", new Object[] {new LinkedHashSet<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -1058,14 +1161,16 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new ArrayList<Integer>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new SequenceType(new ClassType(Integer.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); } @Test @@ -1074,14 +1179,14 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new LinkedHashSet<Integer>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new SetType(new ClassType(Integer.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); } @Test @@ -1090,15 +1195,15 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0), Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); } @Test @@ -1107,15 +1212,16 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0), Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); } @Test @@ -1123,13 +1229,13 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("sum", new Object[] {new ArrayList<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(Integer.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Double.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Double.class), it.next()); } @Test @@ -1137,13 +1243,12 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("sum", new Object[] {new LinkedHashSet<String>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(Integer.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Double.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Double.class), it.next()); } @Test @@ -1152,15 +1257,18 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new ArrayList<Integer>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SequenceType(new ClassType(String.class))); - argTypes.add(new SequenceType(new ClassType(Integer.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class))); + argTypes.add(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new ClassType(String.class)), it.next()); - assertEquals(new SequenceType(new ClassType(Integer.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + String.class)), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), + Integer.class)), it.next()); } @Test @@ -1169,15 +1277,16 @@ public class CollectionServicesValidationTest extends AbstractServicesTest { new LinkedHashSet<Integer>() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new SetType(new ClassType(String.class))); - argTypes.add(new SetType(new ClassType(Integer.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class))); + argTypes.add(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), Integer.class))); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new ClassType(String.class)), it.next()); - assertEquals(new SetType(new ClassType(Integer.class)), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), String.class)), + it.next()); + assertEquals(new SetType(getQueryEnvironment(), new ClassType(getQueryEnvironment(), Integer.class)), + it.next()); } } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ComparableServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ComparableServicesValidationTest.java index c2055bede..6a073d2fc 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ComparableServicesValidationTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ComparableServicesValidationTest.java @@ -29,7 +29,7 @@ public class ComparableServicesValidationTest extends AbstractServicesTest { @Override public void before() throws Exception { super.before(); - getLookupEngine().addServices(ComparableServices.class); + getQueryEnvironment().registerServicePackage(ComparableServices.class); } @Test @@ -37,14 +37,13 @@ public class ComparableServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("lower", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -52,14 +51,13 @@ public class ComparableServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("lowerEqual", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -67,14 +65,13 @@ public class ComparableServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("greater", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -82,14 +79,13 @@ public class ComparableServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("greaterEqual", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -97,14 +93,13 @@ public class ComparableServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("equals", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -112,14 +107,13 @@ public class ComparableServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("differs", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesTest.java index 4a94f5ed4..4f72efc50 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesTest.java @@ -18,7 +18,7 @@ import java.util.List; import java.util.Set; import java.util.logging.Logger; -import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine; +import org.eclipse.acceleo.query.runtime.ILookupEngine; import org.eclipse.acceleo.query.services.EObjectServices; import org.eclipse.acceleo.query.tests.Setup; import org.eclipse.acceleo.query.tests.UnitTestModels; @@ -75,7 +75,7 @@ public class EObjectServicesTest extends AbstractEngineInitializationWithCrossRe root.getESubpackages().add(sub); clazz.getESuperTypes().add(clazz2); Logger logger = Logger.getLogger("testEInverse"); - BasicLookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( + ILookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( clazz2, logger).getLookupEngine(); eObjectServices.setCrossReferencer(queryEnvironnementWithCrossReferencer.getCrossReferencer()); @@ -109,7 +109,7 @@ public class EObjectServicesTest extends AbstractEngineInitializationWithCrossRe root.getESubpackages().add(sub); clazz.getESuperTypes().add(clazz2); Logger logger = Logger.getLogger("testEInverse"); - BasicLookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( + ILookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( clazz2, logger).getLookupEngine(); eObjectServices.setCrossReferencer(queryEnvironnementWithCrossReferencer.getCrossReferencer()); @@ -135,7 +135,7 @@ public class EObjectServicesTest extends AbstractEngineInitializationWithCrossRe root.getESubpackages().add(sub); clazz.getESuperTypes().add(clazz2); Logger logger = Logger.getLogger("testEInverseWithFilter"); - BasicLookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( + ILookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( clazz2, logger).getLookupEngine(); eObjectServices.setCrossReferencer(queryEnvironnementWithCrossReferencer.getCrossReferencer()); @@ -167,7 +167,7 @@ public class EObjectServicesTest extends AbstractEngineInitializationWithCrossRe root.getESubpackages().add(sub); clazz.getESuperTypes().add(clazz2); Logger logger = Logger.getLogger("testEInverseWithFilter"); - BasicLookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( + ILookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( clazz2, logger).getLookupEngine(); eObjectServices.setCrossReferencer(queryEnvironnementWithCrossReferencer.getCrossReferencer()); @@ -195,7 +195,7 @@ public class EObjectServicesTest extends AbstractEngineInitializationWithCrossRe root.getESubpackages().add(sub); clazz.getESuperTypes().add(clazz2); Logger logger = Logger.getLogger("testEInverseWithFilter"); - BasicLookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( + ILookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( clazz2, logger).getLookupEngine(); eObjectServices.setCrossReferencer(queryEnvironnementWithCrossReferencer.getCrossReferencer()); @@ -222,7 +222,7 @@ public class EObjectServicesTest extends AbstractEngineInitializationWithCrossRe root.getESubpackages().add(sub); clazz.getESuperTypes().add(clazz2); Logger logger = Logger.getLogger("testEInverseWithFilter"); - BasicLookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( + ILookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( clazz2, logger).getLookupEngine(); eObjectServices.setCrossReferencer(queryEnvironnementWithCrossReferencer.getCrossReferencer()); @@ -253,7 +253,7 @@ public class EObjectServicesTest extends AbstractEngineInitializationWithCrossRe root.getESubpackages().add(sub); clazz.getESuperTypes().add(clazz2); Logger logger = Logger.getLogger("testEInverseWithFilter"); - BasicLookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( + ILookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( clazz2, logger).getLookupEngine(); eObjectServices.setCrossReferencer(queryEnvironnementWithCrossReferencer.getCrossReferencer()); @@ -280,7 +280,7 @@ public class EObjectServicesTest extends AbstractEngineInitializationWithCrossRe root.getESubpackages().add(sub); clazz.getESuperTypes().add(clazz2); Logger logger = Logger.getLogger("testEInverseWithFilter"); - BasicLookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( + ILookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( clazz2, logger).getLookupEngine(); eObjectServices.setCrossReferencer(queryEnvironnementWithCrossReferencer.getCrossReferencer()); @@ -307,7 +307,7 @@ public class EObjectServicesTest extends AbstractEngineInitializationWithCrossRe root.getESubpackages().add(sub); clazz.getESuperTypes().add(clazz2); Logger logger = Logger.getLogger("testEInverseWithFilter"); - BasicLookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( + ILookupEngine queryEnvironnementWithCrossReferencer = getQueryEnvironnementWithCrossReferencer( clazz2, logger).getLookupEngine(); eObjectServices.setCrossReferencer(queryEnvironnementWithCrossReferencer.getCrossReferencer()); diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesValidationTest.java index c00f754fe..b0f358e92 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesValidationTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesValidationTest.java @@ -29,6 +29,7 @@ import org.eclipse.emf.ecore.EClass; import org.eclipse.emf.ecore.EPackage; import org.eclipse.emf.ecore.EReference; import org.eclipse.emf.ecore.EcorePackage; +import org.eclipse.emf.ecore.impl.EStringToStringMapEntryImpl; import org.eclipse.emf.ecore.util.EcoreUtil; import org.junit.Test; @@ -45,7 +46,7 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { @Override public void before() throws Exception { super.before(); - getLookupEngine().addServices(EObjectServices.class); + getQueryEnvironment().registerServicePackage(EObjectServices.class); } @Test @@ -63,12 +64,12 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("ancestors", new Object[] {EcoreUtil.create(eCls1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -86,26 +87,28 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("ancestors", new Object[] {EcorePackage.eINSTANCE.eClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(7, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEAnnotation())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEModelElement())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEEnum())), it.next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEOperation())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEAnnotation())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEModelElement())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEEnum())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEOperation())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -116,16 +119,16 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("ancestors", new Object[] {EcorePackage.eINSTANCE.eClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEObject())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEObject())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -146,13 +149,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("ancestors", new Object[] {EcoreUtil.create(eCls2), eCls1 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls2)); - argTypes.add(new EClassifierLiteralType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls2)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -171,16 +174,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -192,16 +196,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -213,19 +218,20 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEModelElement() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getETypedElement())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getETypedElement())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getETypedElement())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEOperation())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getETypedElement())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEOperation())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -237,16 +243,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -272,13 +279,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("ancestors", new Object[] {EcoreUtil.create(eCls1), eCls2 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); - argTypes.add(new EClassifierLiteralType(eCls2)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls2)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -306,12 +313,12 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eAllContents", new Object[] {EcoreUtil.create(eCls1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -329,37 +336,36 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eAllContents", new Object[] {EcorePackage.eINSTANCE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(11, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEAnnotation())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE - .getEStringToStringMapEntry())), it.next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEObject())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getETypeParameter())), - it.next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEOperation())), it - .next()); - assertEquals( - new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEStructuralFeature())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEGenericType())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEEnumLiteral())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEParameter())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEAnnotation())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEStringToStringMapEntry())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEObject())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getETypeParameter())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEOperation())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEStructuralFeature())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEGenericType())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEEnumLiteral())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEParameter())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -370,16 +376,16 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eAllContents", new Object[] {EcorePackage.eINSTANCE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEObject())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEObject())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -400,13 +406,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eAllContents", new Object[] {EcoreUtil.create(eCls1), eCls2 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); - argTypes.add(new EClassifierLiteralType(eCls2)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls2)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -425,17 +431,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEPackage() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -447,17 +453,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEPackage() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -469,34 +475,34 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEModelElement() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEModelElement())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEModelElement())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(9, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEAnnotation())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEModelElement())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getETypeParameter())), - it.next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEOperation())), it - .next()); - assertEquals( - new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEStructuralFeature())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEEnumLiteral())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEParameter())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEAnnotation())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEModelElement())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getETypeParameter())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEOperation())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEStructuralFeature())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEEnumLiteral())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEParameter())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -508,16 +514,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -543,13 +550,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eAllContents", new Object[] {EcoreUtil.create(eCls1), eCls2 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); - argTypes.add(new EClassifierLiteralType(eCls2)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls2)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -567,15 +574,16 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eClass", new Object[] {EcorePackage.eINSTANCE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new EClassifierType(EcorePackage.eINSTANCE.getEClass()), it.next()); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass()), it + .next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -596,12 +604,12 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eContainer", new Object[] {EcoreUtil.create(eCls1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -617,16 +625,65 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eContainer", new Object[] {EcorePackage.eINSTANCE.eClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new EClassifierType(EcorePackage.eINSTANCE.getEPackage()), it.next()); - assertEquals(new EClassifierType(EcorePackage.eINSTANCE.getEAnnotation()), it.next()); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage()), it + .next()); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEAnnotation()), + it.next()); + } finally { + getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); + } + } + + // TODO move to BasicLookupEngineTest see https://git.eclipse.org/r/#/c/44251/ + @Test + public void testEContainerOnEStringToStringMapEntryBasicMapping() { + final List<Set<IType>> argTypes = new ArrayList<Set<IType>>(); + argTypes.add(createTypeSet(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEStringToStringMapEntry()))); + argTypes.add(createTypeSet(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEAnnotation()))); + + try { + getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); + final Set<IType> types = getValidationServices().callType("eContainer", argTypes); + assertEquals(1, types.size()); + Iterator<IType> it = types.iterator(); + IType type = it.next(); + assertTrue(type instanceof NothingType); + assertEquals( + "Couldn't find the eContainer(EClassifier=EStringToStringMapEntry,EClassifierLiteral=EAnnotation) service or EOperation", + ((NothingType)type).getMessage()); + } finally { + getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); + } + } + + // TODO move to BasicLookupEngineTest see https://git.eclipse.org/r/#/c/44251/ + @Test + public void testEContainerOnEStringToStringMapEntryCustomMapping() { + final List<Set<IType>> argTypes = new ArrayList<Set<IType>>(); + argTypes.add(createTypeSet(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEStringToStringMapEntry()))); + argTypes.add(createTypeSet(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEAnnotation()))); + + try { + getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); + getQueryEnvironment().registerCustomClassMapping( + EcorePackage.eINSTANCE.getEStringToStringMapEntry(), EStringToStringMapEntryImpl.class); + final Set<IType> types = getValidationServices().callType("eContainer", argTypes); + assertEquals(1, types.size()); + Iterator<IType> it = types.iterator(); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEAnnotation()), + it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -637,15 +694,16 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eContainer", new Object[] {EcorePackage.eINSTANCE.eClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new EClassifierType(EcorePackage.eINSTANCE.getEObject()), it.next()); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject()), it + .next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -666,13 +724,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eContainer", new Object[] {EcoreUtil.create(eCls2), eCls1 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls2)); - argTypes.add(new EClassifierLiteralType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls2)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -690,16 +748,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new EClassifierType(EcorePackage.eINSTANCE.getEClass()), it.next()); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass()), it + .next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -711,16 +770,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new EClassifierType(EcorePackage.eINSTANCE.getEClass()), it.next()); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass()), it + .next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -732,17 +792,21 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEModelElement() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getETypedElement())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getETypedElement())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new EClassifierType(EcorePackage.eINSTANCE.getETypedElement()), it.next()); - assertEquals(new EClassifierType(EcorePackage.eINSTANCE.getEOperation()), it.next()); + assertEquals( + new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getETypedElement()), it + .next()); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEOperation()), + it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -754,16 +818,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new EClassifierType(EcorePackage.eINSTANCE.getEClass()), it.next()); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass()), it + .next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -789,13 +854,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eContainer", new Object[] {EcoreUtil.create(eCls1), eCls2 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); - argTypes.add(new EClassifierLiteralType(eCls2)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls2)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -822,12 +887,12 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eContents", new Object[] {EcoreUtil.create(eCls1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -845,20 +910,20 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eContents", new Object[] {EcorePackage.eINSTANCE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(3, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEAnnotation())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEAnnotation())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -869,16 +934,16 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eContents", new Object[] {EcorePackage.eINSTANCE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEObject())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEObject())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -899,13 +964,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eContents", new Object[] {EcoreUtil.create(eCls1), eCls2 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); - argTypes.add(new EClassifierLiteralType(eCls2)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls2)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -924,17 +989,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEPackage() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -946,17 +1011,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEPackage() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -968,21 +1033,22 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEModelElement() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEModelElement())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEModelElement())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(3, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEAnnotation())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEAnnotation())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -994,16 +1060,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1029,13 +1096,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eContents", new Object[] {EcoreUtil.create(eCls1), eCls2 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); - argTypes.add(new EClassifierLiteralType(eCls2)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls2)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -1053,16 +1120,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eGet", new Object[] {EcorePackage.eINSTANCE, "name" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new ClassType(String.class)); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new EClassifierType(EcorePackage.eINSTANCE.getEJavaObject()), it.next()); + assertEquals(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEJavaObject()), + it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1073,18 +1141,22 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eInverse", new Object[] {EcorePackage.eINSTANCE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(4, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it.next()); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEFactory())), it.next()); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it.next()); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEAnnotation())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEFactory())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEAnnotation())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1095,19 +1167,23 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eInverse", new Object[] {EcorePackage.eINSTANCE, "ePackage" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new ClassType(String.class)); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(4, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it.next()); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEFactory())), it.next()); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it.next()); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEAnnotation())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEFactory())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEAnnotation())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1119,16 +1195,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.eClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1140,16 +1217,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEEnum() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEEnum())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEEnum())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEEnum())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEEnum())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1161,19 +1239,24 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEEnum() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEModelElement())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEModelElement())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(4, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it.next()); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEFactory())), it.next()); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it.next()); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEAnnotation())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEFactory())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEAnnotation())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1184,15 +1267,16 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("eInverse", new Object[] {EcorePackage.eINSTANCE }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEObject())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEObject())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1204,16 +1288,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEEnum() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEEnum())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEEnum())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SetType(new EClassifierType(EcorePackage.eINSTANCE.getEEnum())), it.next()); + assertEquals(new SetType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEEnum())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1225,13 +1310,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEEnum() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEOperation())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEOperation())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -1259,12 +1344,12 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("followingSiblings", new Object[] {EcoreUtil.create(eCls1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -1283,20 +1368,20 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { .eClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(3, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEObject())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEObject())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1308,16 +1393,16 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { .eClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEObject())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEObject())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1339,13 +1424,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { eCls1 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls2)); - argTypes.add(new EClassifierLiteralType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls2)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -1364,17 +1449,18 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClassifier() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClassifier())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEClassifier())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1386,16 +1472,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1407,19 +1494,20 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getENamedElement() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getENamedElement())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getENamedElement())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(2, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getENamedElement())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getENamedElement())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1431,16 +1519,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1467,13 +1556,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { eCls2 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); - argTypes.add(new EClassifierLiteralType(eCls2)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls2)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -1501,12 +1590,12 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("precedingSiblings", new Object[] {EcoreUtil.create(eCls1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -1525,22 +1614,22 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { .eClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(4, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEAnnotation())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE - .getEStringToStringMapEntry())), it.next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEObject())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEAnnotation())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEStringToStringMapEntry())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEObject())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1552,16 +1641,16 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { .eClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEObject())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEObject())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1583,13 +1672,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { eCls1 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls2)); - argTypes.add(new EClassifierLiteralType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls2)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -1608,17 +1697,18 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClassifier() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClassifier())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEClassifier())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1630,16 +1720,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1651,21 +1742,22 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getENamedElement() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getENamedElement())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getENamedElement())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(3, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getENamedElement())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getENamedElement())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1677,16 +1769,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1713,13 +1806,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { eCls2 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); - argTypes.add(new EClassifierLiteralType(eCls2)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls2)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -1747,12 +1840,12 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("siblings", new Object[] {EcoreUtil.create(eCls1) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -1770,24 +1863,24 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("siblings", new Object[] {EcorePackage.eINSTANCE.eClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(5, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEAnnotation())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE - .getEStringToStringMapEntry())), it.next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEObject())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEAnnotation())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEStringToStringMapEntry())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEObject())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1798,16 +1891,16 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("siblings", new Object[] {EcorePackage.eINSTANCE.eClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEObject())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEObject())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1828,13 +1921,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("siblings", new Object[] {EcoreUtil.create(eCls2), eCls1 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls2)); - argTypes.add(new EClassifierLiteralType(eCls1)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls2)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls1)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); @@ -1853,17 +1946,18 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClassifier() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClassifier())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getEClassifier())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1875,16 +1969,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEObject())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEObject())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1896,21 +1991,22 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getENamedElement() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getENamedElement())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE + .getENamedElement())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(3, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClassifier())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())), it - .next()); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getENamedElement())), it - .next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClassifier())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEPackage())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getENamedElement())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1922,16 +2018,17 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { EcorePackage.eINSTANCE.getEClass() }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(EcorePackage.eINSTANCE.getEPackage())); - argTypes.add(new EClassifierLiteralType(EcorePackage.eINSTANCE.getEClass())); + argTypes.add(new EClassifierType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEPackage())); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), EcorePackage.eINSTANCE.getEClass())); try { getQueryEnvironment().registerEPackage(EcorePackage.eINSTANCE); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new SequenceType(new EClassifierType(EcorePackage.eINSTANCE.getEClass())), it.next()); + assertEquals(new SequenceType(getQueryEnvironment(), new EClassifierType(getQueryEnvironment(), + EcorePackage.eINSTANCE.getEClass())), it.next()); } finally { getQueryEnvironment().removeEPackage(EcorePackage.eINSTANCE.getNsPrefix()); } @@ -1957,13 +2054,13 @@ public class EObjectServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("siblings", new Object[] {EcoreUtil.create(eCls1), eCls2 }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new EClassifierType(eCls1)); - argTypes.add(new EClassifierLiteralType(eCls2)); + argTypes.add(new EClassifierType(getQueryEnvironment(), eCls1)); + argTypes.add(new EClassifierLiteralType(getQueryEnvironment(), eCls2)); try { getQueryEnvironment().registerEPackage(ePkg); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service + .getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); IType next = it.next(); diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesTest.java index c997b2c5f..8c3cb2247 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesTest.java @@ -28,7 +28,7 @@ public class NumberServicesTest extends AbstractServicesTest { @Override public void before() throws Exception { super.before(); - getLookupEngine().addServices(NumberServices.class); + getQueryEnvironment().registerServicePackage(NumberServices.class); numServices = new NumberServices(); } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesValidationTest.java index 4e4692314..e3af2ff6d 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesValidationTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesValidationTest.java @@ -29,7 +29,7 @@ public class NumberServicesValidationTest extends AbstractServicesTest { @Override public void before() throws Exception { super.before(); - getLookupEngine().addServices(NumberServices.class); + getQueryEnvironment().registerServicePackage(NumberServices.class); } @Test @@ -37,13 +37,12 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("unaryMin", new Object[] {Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -51,13 +50,12 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("unaryMin", new Object[] {Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Double.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Double.class), it.next()); } @Test @@ -65,14 +63,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("add", new Object[] {Integer.valueOf(0), Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -80,14 +77,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("add", new Object[] {Double.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Double.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Double.class), it.next()); } @Test @@ -95,14 +91,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("sub", new Object[] {Integer.valueOf(0), Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -110,14 +105,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("sub", new Object[] {Double.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Double.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Double.class), it.next()); } @Test @@ -125,14 +119,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("mult", new Object[] {Integer.valueOf(0), Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -140,14 +133,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("mult", new Object[] {Double.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Double.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Double.class), it.next()); } @Test @@ -156,14 +148,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { new Object[] {Integer.valueOf(0), Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -171,14 +162,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("divOp", new Object[] {Double.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Double.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Double.class), it.next()); } @Test @@ -187,14 +177,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -203,14 +192,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { new Object[] {Double.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -219,14 +207,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -235,14 +222,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -251,14 +237,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -267,14 +252,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -283,14 +267,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { new Object[] {Integer.valueOf(0), Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -298,14 +281,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("equals", new Object[] {Double.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -314,14 +296,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -330,14 +311,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { new Object[] {Double.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -346,14 +326,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -362,14 +341,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -377,13 +355,12 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("abs", new Object[] {Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -391,13 +368,12 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("abs", new Object[] {Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Double.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Double.class), it.next()); } @Test @@ -405,13 +381,12 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("floor", new Object[] {Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -419,13 +394,12 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("floor", new Object[] {Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -433,14 +407,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("max", new Object[] {Integer.valueOf(0), Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -448,14 +421,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("max", new Object[] {Double.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Double.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Double.class), it.next()); } @Test @@ -463,14 +435,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("min", new Object[] {Integer.valueOf(0), Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -478,14 +449,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("min", new Object[] {Double.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Double.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Double.class), it.next()); } @Test @@ -493,13 +463,12 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("round", new Object[] {Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -507,13 +476,12 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("round", new Object[] {Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -521,14 +489,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("div", new Object[] {Integer.valueOf(0), Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -536,14 +503,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("div", new Object[] {Double.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -551,14 +517,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("mod", new Object[] {Integer.valueOf(0), Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -566,14 +531,13 @@ public class NumberServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("mod", new Object[] {Double.valueOf(0), Double.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(Double.class)); - argTypes.add(new ClassType(Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Double.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/StringServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/StringServicesValidationTest.java index c7cc20e5f..96fed432d 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/StringServicesValidationTest.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/StringServicesValidationTest.java @@ -29,7 +29,7 @@ public class StringServicesValidationTest extends AbstractServicesTest { @Override public void before() throws Exception { super.before(); - getLookupEngine().addServices(StringServices.class); + getQueryEnvironment().registerServicePackage(StringServices.class); } @Test @@ -37,14 +37,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("concat", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -52,14 +51,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("add", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -67,15 +65,14 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("replace", new Object[] {"", "", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -83,15 +80,14 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("replaceAll", new Object[] {"", "", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -99,14 +95,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("prefix", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -114,14 +109,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("contains", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -129,14 +123,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("matches", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -144,14 +137,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("endsWith", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -159,14 +151,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("startsWith", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -174,14 +165,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("equalsIgnoreCase", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -189,14 +179,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("first", new Object[] {"", Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -204,14 +193,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("last", new Object[] {"", Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -219,14 +207,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("lastIndex", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -234,14 +221,13 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("index", new Object[] {"", "" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -249,15 +235,14 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("index", new Object[] {"", "", Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -265,15 +250,14 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("lastIndex", new Object[] {"", "", Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -281,13 +265,12 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("toLower", new Object[] {"" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -295,13 +278,12 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("toLowerFirst", new Object[] {"" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -309,13 +291,12 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("toUpper", new Object[] {"" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -323,13 +304,12 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("toUpperFirst", new Object[] {"" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -337,13 +317,12 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("isAlpha", new Object[] {"" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -351,13 +330,12 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("isAlphaNum", new Object[] {"" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Boolean.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Boolean.class), it.next()); } @Test @@ -365,13 +343,12 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("size", new Object[] {"" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -380,15 +357,14 @@ public class StringServicesValidationTest extends AbstractServicesTest { Integer.valueOf(0) }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); - argTypes.add(new ClassType(Integer.class)); - argTypes.add(new ClassType(Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); + argTypes.add(new ClassType(getQueryEnvironment(), Integer.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(String.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), String.class), it.next()); } @Test @@ -396,13 +372,12 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("toInteger", new Object[] {"" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Integer.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Integer.class), it.next()); } @Test @@ -410,13 +385,12 @@ public class StringServicesValidationTest extends AbstractServicesTest { final IService service = serviceLookUp("toReal", new Object[] {"" }); assertTrue(service != null); final List<IType> argTypes = new ArrayList<IType>(); - argTypes.add(new ClassType(String.class)); + argTypes.add(new ClassType(getQueryEnvironment(), String.class)); - final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment() - .getEPackageProvider(), argTypes); + final Set<IType> types = service.getType(getValidationServices(), getQueryEnvironment(), argTypes); assertEquals(1, types.size()); Iterator<IType> it = types.iterator(); - assertEquals(new ClassType(Double.class), it.next()); + assertEquals(new ClassType(getQueryEnvironment(), Double.class), it.next()); } } diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/AcceleoQueryInterpreter.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/AcceleoQueryInterpreter.java index ae2b34c5a..cae9e1c13 100644 --- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/AcceleoQueryInterpreter.java +++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/AcceleoQueryInterpreter.java @@ -84,7 +84,7 @@ public class AcceleoQueryInterpreter extends AbstractEngineInitializationWithCro @Override public Set<IType> caseEObjectVariable(EObjectVariable object) { Set<IType> types = new LinkedHashSet<IType>(); - types.add(new EClassifierType(object.getValue().getTarget().eClass())); + types.add(new EClassifierType(queryEnvironment, object.getValue().getTarget().eClass())); return types; } }; @@ -160,7 +160,7 @@ public class AcceleoQueryInterpreter extends AbstractEngineInitializationWithCro } Map<String, Set<IType>> variableTypes = Maps.newHashMap(); Set<IType> startingTypes = new LinkedHashSet<IType>(); - startingTypes.add(new EClassifierType(startingPoint.eClass())); + startingTypes.add(new EClassifierType(queryEnvironment, startingPoint.eClass())); variableTypes.put("self", startingTypes); for (Variable var : q.getVariables()) { variableTypes.put(var.getName(), varTypeSwitch.doSwitch(var)); |