*   Zeligsoft - Bug 249496

		addTest(ClientContextTest.suite());

   <!-- Constraints only used for client-context inclusion/exclusion testing -->

   <extension name="Contraints for client-context testing" point="org.eclipse.emf.validation.constraintProviders">

     <category id="clientContextTest" name="JUnit Client Context Testing Context"/>

     <category id="clientContextTest/one" name="First level of nesting"/>

     <category id="clientContextTest/one/two" name="Second level of nesting"/>

     <category id="clientContextTest/one/twoA" name="Second level of nesting (A)"/>

     <category id="clientContextTest/one/two/three" name="Third level of nesting"/>

     <category id="clientContextTest/one/two/threeA" name="Third level of nesting (A)"/>

     <constraintProvider>

         <package namespaceUri="http://www.eclipse.org/emf/2002/Ecore" />

         <constraints categories="clientContextTest/one">

            <constraint name="Dummy1.1" statusCode="1" lang="OCL" id="clientContext.1.1">

               <message>Nothing to say.</message>

               <target class="EAnnotation"/>

               true

            </constraint>

            <constraint name="Dummy1.2" statusCode="1" lang="OCL" id="clientContext.1.2">

               <message>Nothing to say.</message>

               <target class="EAnnotation"/>

               true

            </constraint>

         </constraints>

         <constraints categories="clientContextTest/one/two">

            <constraint name="Dummy2.1" statusCode="1" lang="OCL" id="clientContext.2.1">

               <message>Nothing to say.</message>

               <target class="EAnnotation"/>

               true

            </constraint>

            <constraint name="Dummy2.2" statusCode="1" lang="OCL" id="clientContext.2.2">

               <message>Nothing to say.</message>

               <target class="EAnnotation"/>

               true

            </constraint>

         </constraints>

         <constraints categories="clientContextTest/one/twoA">

            <constraint name="Dummy2a.1" statusCode="1" lang="OCL" id="clientContext.2a.1">

               <message>Nothing to say.</message>

               <target class="EAnnotation"/>

               true

            </constraint>

            <constraint name="Dummy2a.2" statusCode="1" lang="OCL" id="clientContext.2a.2">

               <message>Nothing to say.</message>

               <target class="EAnnotation"/>

               true

            </constraint>

         </constraints>

         <constraints categories="clientContextTest/one/two/three">

            <constraint name="Dummy3.1" statusCode="1" lang="OCL" id="clientContext.3.1">

               <message>Nothing to say.</message>

               <target class="EAnnotation"/>

               true

            </constraint>

            <constraint name="Dummy3.2" statusCode="1" lang="OCL" id="clientContext.3.2">

               <message>Nothing to say.</message>

               <target class="EAnnotation"/>

               true

            </constraint>

         </constraints>

         <constraints categories="clientContextTest/one/two/threeA">

            <constraint name="Dummy3a.1" statusCode="1" lang="OCL" id="clientContext.3a.1">

               <message>Nothing to say.</message>

               <target class="EAnnotation"/>

               true

            </constraint>

            <constraint name="Dummy3a.2" statusCode="1" lang="OCL" id="clientContext.3a.2">

               <message>Nothing to say.</message>

               <target class="EAnnotation"/>

               true

            </constraint>

         </constraints>

      </constraintProvider>

   </extension>

   <!-- A client-context only used for inclusion/exclusion testing -->

   <extension point="org.eclipse.emf.validation.constraintBindings">

      <clientContext

            id="org.eclipse.emf.validation.tests.testContextToExtend">

          <!-- We are never enabled -->

          <enablement>

            <systemTest property="BOGUS_SYSTEM_PROPERTY" value="1"/>

         </enablement>

      </clientContext>

      <binding context="org.eclipse.emf.validation.tests.testContextToExtend">

         <category ref="clientContextTest/one/two/three"/>

      </binding>

   </extension>

   <extension point="org.eclipse.emf.validation.constraintBindings">

      <clientContext

            id="org.eclipse.emf.validation.tests.testcontext">

          <!-- We are never enabled -->

          <enablement>

            <systemTest property="BOGUS_SYSTEM_PROPERTY" value="1"/>

         </enablement>

      </clientContext>

      <binding context="org.eclipse.emf.validation.tests.testcontext">

         <category ref="clientContextTest/one"/>

         <excludeCategory ref="clientContextTest/one/two"/>

         <extendClientContext ref="org.eclipse.emf.validation.tests.testContextToExtend"/>

         <excludeConstraint ref="org.eclipse.emf.validation.tests.clientContext.1.1"/>

         <excludeConstraint ref="org.eclipse.emf.validation.tests.clientContext.2a.1"/>

         <constraint ref="org.eclipse.emf.validation.tests.clientContext.2.2"/>

         <constraint ref="org.eclipse.emf.validation.tests.clientContext.3a.2"/>

      </binding>

   </extension>

/**

 * <copyright>

 * 

 * Copyright (c) 2008 Zeligsoft Inc. and others.

 * All rights reserved.   This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *   Zeligsoft - Initial API and implementation

 * 

 * </copyright>

 *

 * $Id$

 */

package org.eclipse.emf.validation.internal.service.impl.tests;

import junit.framework.Test;

import junit.framework.TestCase;

import junit.framework.TestSuite;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.emf.ecore.EcoreFactory;

import org.eclipse.emf.validation.IValidationContext;

import org.eclipse.emf.validation.internal.service.ClientContext;

import org.eclipse.emf.validation.internal.service.ClientContextManager;

import org.eclipse.emf.validation.internal.service.IClientContext;

import org.eclipse.emf.validation.model.EvaluationMode;

import org.eclipse.emf.validation.model.IModelConstraint;

import org.eclipse.emf.validation.service.ConstraintRegistry;

import org.eclipse.emf.validation.service.IConstraintDescriptor;

import org.eclipse.emf.validation.service.ModelValidationService;

/**

 * Tests the {@link ClientContext} class.

 * 

 * @author Christian W. Damus (cdamus)

 */

@SuppressWarnings("nls")

public class ClientContextTest

		extends TestCase {

	private IModelConstraint constraint1_1;

	private IModelConstraint constraint1_2;

	private IModelConstraint constraint2_1;

	private IModelConstraint constraint2_2;

	private IModelConstraint constraint2a_1;

	private IModelConstraint constraint2a_2;

	private IModelConstraint constraint3_1;

	private IModelConstraint constraint3_2;

	private IModelConstraint constraint3a_1;

	private IModelConstraint constraint3a_2;

	private IClientContext fixture;

	/**

	 * Initialize me with my name.

	 * 

	 * @param name

	 *            my name

	 */

	public ClientContextTest(String name) {

		super(name);

	}

	public static Test suite() {

		return new TestSuite(ClientContextTest.class, "Client context tests");

	}

	public void test_includedChildOfExcludedCategory() {

		assertTrue("Constraint is excluded", fixture.includes(constraint3_1));

		assertTrue("Constraint is excluded", fixture.includes(constraint3_2));

	}

	public void test_constraintExcludedFromIncludedCategory() {

		assertFalse("Constraint is included", fixture.includes(constraint1_1));

		assertTrue("Constraint is excluded", fixture.includes(constraint1_2));

	}

	public void test_constraintIncludedInExcludedCategory() {

		assertFalse("Constraint is included", fixture.includes(constraint2_1));

		assertTrue("Constraint is excluded", fixture.includes(constraint2_2));

	}

	public void test_constraintExcludedFromIncludedCategory_nested() {

		assertFalse("Constraint is included", fixture.includes(constraint2a_1));

		assertTrue("Constraint is excluded", fixture.includes(constraint2a_2));

	}

	public void test_constraintIncludedInExcludedCategory_nested() {

		assertFalse("Constraint is included", fixture.includes(constraint3a_1));

		assertTrue("Constraint is excluded", fixture.includes(constraint3a_2));

	}

	//

	// Test framework

	//

	@Override

	protected void setUp()

			throws Exception {

		super.setUp();

		fixture = ClientContextManager.getInstance().getClientContext(

			"org.eclipse.emf.validation.tests.testcontext");

		final String prefix = "org.eclipse.emf.validation.tests.clientContext.";

		final ConstraintRegistry reg = ConstraintRegistry.getInstance();

		// cause our test constraints to be created

		ModelValidationService.getInstance().newValidator(EvaluationMode.BATCH)

			.validate(EcoreFactory.eINSTANCE.createEAnnotation());

		constraint1_1 = new TestConstraint(reg.getDescriptor(prefix + "1.1"));

		constraint1_2 = new TestConstraint(reg.getDescriptor(prefix + "1.2"));

		constraint2_1 = new TestConstraint(reg.getDescriptor(prefix + "2.1"));

		constraint2_2 = new TestConstraint(reg.getDescriptor(prefix + "2.2"));

		constraint2a_1 = new TestConstraint(reg.getDescriptor(prefix + "2a.1"));

		constraint2a_2 = new TestConstraint(reg.getDescriptor(prefix + "2a.2"));

		constraint3_1 = new TestConstraint(reg.getDescriptor(prefix + "3.1"));

		constraint3_2 = new TestConstraint(reg.getDescriptor(prefix + "3.2"));

		constraint3a_1 = new TestConstraint(reg.getDescriptor(prefix + "3a.1"));

		constraint3a_2 = new TestConstraint(reg.getDescriptor(prefix + "3a.2"));

	}

	private static final class TestConstraint

			implements IModelConstraint {

		private IConstraintDescriptor desc;

		TestConstraint(IConstraintDescriptor desc) {

			this.desc = desc;

		}

		public IStatus validate(IValidationContext c) {

			return Status.OK_STATUS;

		}

		public IConstraintDescriptor getDescriptor() {

			return desc;

		}

	}

}

 *    Zeligsoft - Bug 249496

	public static String binding_noClientContextRef_WARN_;

#     Zeligsoft - Bug 249496

# Indicates that a client context extension does not actually specify any context.

# args:

#   0 - the client context ID of the binding

#   1 - the ID of the plug-in defining the offending extension

binding_noClientContextRef_WARN_= Constraint binding for client context {0} does \

	not reference an extended client context in plug-in {1}.

	public static final int BINDING_NO_CLIENT_CONTEXT = 124;

			final String name = element.getName();

	/**

	 * A chain-structured constraint-binding filter. Filters are chained in the

	 * order in which they are parsed from the extension point. The head of the

	 * filter chain applies its filter and, if it doesn't find any match,

	 * delegates down the chain. The chain is terminated by the {@link #NULL}

	 * filter, which always excludes the constraint.

	 * 

	 * @author Christian W. Damus (cdamus)

	 */

	private static class BindingFilter {

		private BindingFilter next;

		/** A filter that excludes every constraint. */

		static final BindingFilter NULL = new BindingFilter() {

			boolean getBinding(IConstraintDescriptor constraint) {

				return false;

			}

		};

		/**

		 * Queries whether the specified constraint is definitely included (

		 * <code>true</code>) or excluded (<code>false</code>) from the client

		 * context. If I don't have definitive knowledge of this constraint, I

		 * delegate to the next in the chain.

		 * 

		 * @param constraint

		 *            a constraint descriptor

		 * @return whether the constraint is included

		 */

		boolean getBinding(IConstraintDescriptor constraint) {

			return isExcluded(constraint)

				? false

				: isIncluded(constraint)

					? true

					: next().getBinding(constraint);

		}

		/**

		 * Queries whether I know that a constraint is included.

		 * 

		 * @param constraint

		 *            a constraint descriptor

		 * @return <code>true</code> if the constraint is included, or

		 *         <code>false</code> if I do not know

		 */

		boolean isExcluded(IConstraintDescriptor constraint) {

			return false;

		}

		/**

		 * Queries whether I know that a constraint is excluded.

		 * 

		 * @param constraint

		 *            a constraint descriptor

		 * @return <code>true</code> if the constraint is excluded, or

		 *         <code>false</code> if I do not know

		 */

		boolean isIncluded(IConstraintDescriptor constraint) {

			return false;

		}

		/**

		 * Obtains the next filter in my chain.

		 * 

		 * @return my next, or <code>null</code> if I am the end of the chain

		 */

		BindingFilter next() {

			return next;

		}

		/**

		 * Assigns my next filter.

		 * 

		 * @param next

		 *            my new next

		 */

		void setNext(BindingFilter next) {

			this.next = next;

		}

		/**

		 * Obtains a filter, chaining me, that definitively includes the

		 * specified category and all of its constraints and sub-categories. The

		 * result may be optimized to be myself augmented with this category, if

		 * I am a filter of the appropriate kind. Or, the result may be a new

		 * filter chain.

		 * 

		 * @param category

		 *            a category to include

		 * 

		 * @return a filter that includes the category

		 */

		BindingFilter includeCategory(String category) {

			CategoryInclusion result = new CategoryInclusion(category);

			result.setNext(this);

			return result;

		}

		/**

		 * Obtains a filter, chaining me, that definitively excludes the

		 * specified category and all of its constraints and sub-categories. The

		 * result may be optimized to be myself augmented with this category, if

		 * I am a filter of the appropriate kind. Or, the result may be a new

		 * filter chain.

		 * 

		 * @param category

		 *            a category to exclude

		 * 

		 * @return a filter that excludes the category

		 */

		BindingFilter excludeCategory(String category) {

			CategoryExclusion result = new CategoryExclusion(category);

			result.setNext(this);

			return result;

		}

		/**

		 * Obtains a filter, chaining me, that definitively includes the

		 * specified constraint. The result may be optimized to be myself

		 * augmented with this constraint, if I am a filter of the appropriate

		 * kind. Or, the result may be a new filter chain.

		 * 

		 * @param constraint

		 *            a constraint to include

		 * 

		 * @return a filter that includes the constraint

		 */

		BindingFilter includeConstraint(String constraint) {

			ConstraintInclusion result = new ConstraintInclusion(constraint);

			result.setNext(this);

			return result;

		}

		/**

		 * Obtains a filter, chaining me, that definitively excludes the

		 * specified constraint. The result may be optimized to be myself

		 * augmented with this constraint, if I am a filter of the appropriate

		 * kind. Or, the result may be a new filter chain.

		 * 

		 * @param constraint

		 *            a constraint to exclude

		 * 

		 * @return a filter that excludes the constraint

		 */

		BindingFilter excludeConstraint(String constraint) {

			ConstraintExclusion result = new ConstraintExclusion(constraint);

			result.setNext(this);

			return result;

		}

		/**

		 * Obtains a filter, chaining me, that inherits the constraints bound to

		 * the specified client-context. The result may be optimized to be

		 * myself myself augmented with this client-context, if I am a filter of

		 * the appropriate kind. Or, the result may be a new filter chain.

		 * 

		 * @param clientContext

		 *            a client-context to extend

		 * 

		 * @return a filter that extends the client-context

		 */

		BindingFilter extendClientContext(String clientContext) {

			ContextExtension result = new ContextExtension(clientContext);

			result.setNext(this);

			return result;

		}

	}

	/**

	 * A binding filter that definitively includes one or more constraints.

	 * 

	 * @author Christian W. Damus (cdamus)

	 */

	private static class ConstraintInclusion

			extends BindingFilter {

		private final Set<String> constraints = new java.util.HashSet<String>();

		ConstraintInclusion(String constraint) {

			constraints.add(constraint);

		}

		@Override

		boolean isIncluded(IConstraintDescriptor constraint) {

			return constraints.contains(constraint.getId());

		}

		@Override

		BindingFilter includeConstraint(String constraint) {

			constraints.add(constraint);

			return this;

		}

	}

	/**

	 * A binding filter that definitively excludes one or more constraints.

	 * 

	 * @author Christian W. Damus (cdamus)

	 */

	private static class ConstraintExclusion

			extends BindingFilter {

		private final Set<String> constraints = new java.util.HashSet<String>();

		ConstraintExclusion(String constraint) {

			constraints.add(constraint);

		}

		@Override

		boolean isExcluded(IConstraintDescriptor constraint) {

			return constraints.contains(constraint.getId());

		}

		@Override

		BindingFilter excludeConstraint(String constraint) {

			constraints.add(constraint);

			return this;

		}

	}

	/**

	 * A binding filter that definitively includes one or more categories.

	 * 

	 * @author Christian W. Damus (cdamus)

	 */

	private static class CategoryInclusion

			extends BindingFilter {

		private final CategorySet categories;

		CategoryInclusion(String category) {

			categories = new CategorySet(category);

		}

		@Override

		boolean isIncluded(IConstraintDescriptor constraint) {

			return categories.containsAny(constraint.getCategories());

		}

		@Override

		BindingFilter includeCategory(String category) {

			categories.add(category);

			return this;

		}

	}

	/**

	 * A binding filter that definitively excludes one or more categories.

	 * 

	 * @author Christian W. Damus (cdamus)

	 */

	private static class CategoryExclusion

			extends BindingFilter {

		private final CategorySet categories;

		CategoryExclusion(String category) {

			categories = new CategorySet(category);

		}

		@Override

		boolean isExcluded(IConstraintDescriptor constraint) {

			return categories.containsAny(constraint.getCategories());

		}

		@Override

		BindingFilter excludeCategory(String category) {

			categories.add(category);

			return this;

		}

	}

	private static final class CategorySet {

		private final Set<String> categories = new java.util.HashSet<String>();

		CategorySet(String category) {

			categories.add(category);

		}

		boolean containsAny(Collection<? extends Category> categories) {

			boolean result = false;

			for (Category next : categories) {

				if (contains(next)) {

					result = true;

					break;

				}

			}

			return result;

		}

		boolean contains(Category category) {

			boolean result = false;

			String path = category.getPath();

			result = categories.contains(path);

			if (!result) {

				// search the ancestors

				Category ancestor = category.getParent();

				while ((ancestor != null) && !result) {

					result = categories.contains(ancestor.getPath());

					ancestor = ancestor.getParent();

				}

				if (result) {

					// cache the original category for quicker results on the

					// next category that it contains

					add(path);

				}

			}

			return result;

		}

		void add(String category) {

			categories.add(category);

		}

	}

	/**

	 * A binding filter that inherits the bindings of another context.

	 * 

	 * @author Christian W. Damus (cdamus)

	 */

	private static class ContextExtension

			extends BindingFilter {

		private final Set<String> extendedContextIDs = new java.util.HashSet<String>();

		private volatile Set<ClientContext> extendedContexts;

		ContextExtension(String clientContext) {

			extendedContextIDs.add(clientContext);

		}

		@Override

		boolean isIncluded(IConstraintDescriptor constraint) {

			if (extendedContexts == null) {

				// do this lazily because we don't know the order in which

				// client-contexts will be discovered in the extension registry

				ClientContextManager mgr = ClientContextManager.getInstance();

				Set<ClientContext> contexts = new java.util.HashSet<ClientContext>();

				synchronized (extendedContextIDs) {

					for (String next : extendedContextIDs) {

						contexts

							.add((ClientContext) mgr.getClientContext(next));

					}

					extendedContexts = contexts;

				}

			}

			for (ClientContext extended : extendedContexts) {

				if (extended.includes(constraint)) {

					return true;

				}

			}

			return false;

		}

		@Override

		BindingFilter extendClientContext(String clientContext) {

			synchronized (extendedContextIDs) {

				extendedContexts = null; // purge

				extendedContextIDs.add(clientContext);

			}

			return this;

		}

	}

      <annotation>

         <appinfo>

            <meta.element />

         </appinfo>

      </annotation>

</p>

<p>

Since the 1.3 release, selective exclusion of constraints and sub-categories that are contained by included categories is supported.  Within a <code><binding></code> element, ordering of inclusion and exclusion elements is significant:  they are processed in the order in which they are declared in the extension.  However, the order of inclusions and exclusions in separate bindings for the same context is undefined.

   <element name="extendClientContext">

      <annotation>

         <documentation>

            Since 1.3.  References a client-context that the bound context extends.  Conceptually, this declares that objects matching the referenced context also match my bound context.  In practice, this means that my bound context inherits all of the constraint bindings from the referenced context.

<br/><br/>

Of course, subsequent exclusions can filter out unwanted constraints, too.  <b>Note</b>, also, that this effects a dependency on the referenced client context and also imposes a partial ordering on the bindings.  All of the bindings contributed to the referenced context are applied before any inclusions or exclusions that follow the <code><extendClientContext></code> element in the current <code><binding></code>.

         </documentation>

      </annotation>

      <complexType>

         <attribute name="ref" type="string" use="required">

            <annotation>

               <documentation>

                  References the ID of a client-context to extend.  All constraint bindings of the client context are inherited by this binding.

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="excludeCategory">

      <annotation>

         <documentation>

            Since 1.3.  Excludes a constraint category from a client context

<code><binding></code>.  All of the referenced

category's constraints and those of any sub-categories

(recursively) are excluded.  This is useful when including some parent category, to filter out selective sub-categories.  Not only is it simpler than explicitly including all of the desired sub-categories, but it ensures that sub-categories that are added later will be included implicitly.

         </documentation>

      </annotation>

      <complexType>

         <attribute name="ref" type="string" use="required">

            <annotation>

               <documentation>

                  References the fully-qualified ID of a constraint category to

exclude from the client context. The category ID does not

necessarily include its contributing plug-in ID, but is a

path reflecting the hierarchical structure of categories.

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="excludeConstraint">

      <annotation>

         <documentation>

            Since 1.3.  Excludes a constraint from a client context

<code><binding></code>. This is useful when including some parent category, to filter out selective constraints cointained within it.  Not only is it simpler than explicitly including all of the desired constraints and sub-categories, but it ensures that constraints and sub-categories that are added later will be included implicitly.

         </documentation>

      </annotation>

      <complexType>

         <attribute name="ref" type="string" use="required">

            <annotation>

               <documentation>

                  References the fully-qualified ID of a constraint to exclude

from the client context.  The ID includes the constraint's

contributing plug-in ID, if it is not explicit in the XML

definition of the constraint.

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>