tests/org.eclipse.wst.xml.ui.tests/src/org/eclipse/wst/xml/ui/tests/TestSourceValidationFramework.java - sourceediting/webtools.sourceediting.tests - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006 IBM Corporation 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:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.wst.xml.ui.tests;

 import java.io.ByteArrayInputStream;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;

 import junit.framework.TestCase;

 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IProjectDescription;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.core.runtime.content.IContentDescription;
 import org.eclipse.core.runtime.content.IContentType;
 import org.eclipse.jface.preference.IPreferenceStore;
 import org.eclipse.jface.text.reconciler.IReconciler;
 import org.eclipse.jface.text.source.SourceViewerConfiguration;
 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.IWorkbenchPage;
 import org.eclipse.ui.IWorkbenchWindow;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.ide.IDE;
 import org.eclipse.ui.texteditor.ITextEditor;
 import org.eclipse.wst.sse.ui.StructuredTextEditor;
 import org.eclipse.wst.sse.ui.internal.SSEUIPlugin;
 import org.eclipse.wst.sse.ui.internal.provisional.preferences.CommonEditorPreferenceNames;
 import org.eclipse.wst.sse.ui.internal.reconcile.DocumentRegionProcessor;
 import org.eclipse.wst.sse.ui.internal.reconcile.validator.ValidatorMetaData;
 import org.eclipse.wst.sse.ui.internal.reconcile.validator.ValidatorStrategy;

 /**
  * Tests reconciler in an open editor. The location of this class is awkward
  * in that it refers to content types declared in plugins that aren't required
  * to be present.
  */
 public class TestSourceValidationFramework extends TestCase {
 	/**
 	 * THIS SUBCLASS IS FOR TESTING ONLY
 	 */
 	public static class TestStructuredTextEditor extends StructuredTextEditor {
 		public SourceViewerConfiguration textViewerConfiguration = null;

 		protected void setSourceViewerConfiguration(SourceViewerConfiguration config) {
 			super.setSourceViewerConfiguration(config);
 			textViewerConfiguration = config;
 		}
 	}

 	private static final String PROJECT_NAME = "TestSourceValidationFramework";

 	private static final String SEPARATOR = String.valueOf(IPath.SEPARATOR);

 	private boolean fPreviousReconcilerPref;

 	public TestSourceValidationFramework() {
 		super("TestSourceValidationFramework");
 	}

 	private IFile ensureFileIsAccessible(String filePath, byte[] contents) {
 		IFile blankFile = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(filePath));
 		if (blankFile != null && !blankFile.isAccessible()) {
 			try {
 				byte[] bytes = contents;
 				if (bytes == null) {
 					bytes = new byte[0];
 				}
 				blankFile.create(new ByteArrayInputStream(bytes), true, new NullProgressMonitor());
 			}
 			catch (CoreException e) {
 				e.printStackTrace();
 			}
 		}
 		return blankFile;
 	}

 	private IContentType[] detectContentTypes(String fileName) {
 		IContentType[] types = null;
 		IFile file = ensureFileIsAccessible(PROJECT_NAME + SEPARATOR + fileName, null);

 		types = Platform.getContentTypeManager().findContentTypesFor(file.getName());
 		if (types.length == 0) {
 			IContentDescription d = null;
 			try {
 				// optimized description lookup, might not succeed
 				d = file.getContentDescription();
 				if (d != null) {
 					types = new IContentType[]{d.getContentType()};
 				}
 			}
 			catch (CoreException e) {
 				/*
 				 * should not be possible given the accessible and file type
 				 * check above
 				 */
 			}
 		}
 		if (types == null) {
 			types = Platform.getContentTypeManager().findContentTypesFor(file.getName());
 		}
 		return types;
 	}

 	private String[] detectContentTypeIDs(String fileName) {
 		IContentType[] types = detectContentTypes(fileName);
 		String[] ids = new String[types.length];
 		for (int i = 0; i < types.length; i++) {
 			ids[i] = types[i].getId();
 		}
 		return ids;
 	}

 	private boolean identicalContents(Object o1[], Object o2[]) {
 		if (o1.length == 0 && o2.length == 0)
 			return true;

 		Object[] array1 = new Object[o1.length];
 		Object[] array2 = new Object[o2.length];
 		System.arraycopy(o1, 0, array1, 0, o1.length);
 		System.arraycopy(o2, 0, array2, 0, o2.length);
 		Arrays.sort(array1);
 		Arrays.sort(array2);
 		return Arrays.equals(array1, array2);
 	}


 	private void ensureProjectIsAccessible(String projName) {
 		IProjectDescription description = ResourcesPlugin.getWorkspace().newProjectDescription(projName);

 		IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projName);
 		try {
 			if (!project.exists())
 				project.create(description, new NullProgressMonitor());
 			if (!project.isAccessible())
 				project.open(new NullProgressMonitor());
 		}
 		catch (CoreException e) {
 			e.printStackTrace();
 		}
 	}

 	private List getSourceValidatorIDs(String fileName) throws Exception {
 		List validatorIds = new ArrayList(1);
 		IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
 		IWorkbenchPage page = workbenchWindow.getActivePage();

 		IFile file = ensureFileIsAccessible(PROJECT_NAME + SEPARATOR + fileName, null);
 		IEditorPart editor = IDE.openEditor(page, file, TestStructuredTextEditor.class.getName(), true);

 		ITextEditor textEditor = (ITextEditor) editor.getAdapter(ITextEditor.class);
 		TestStructuredTextEditor testTextEditor = (TestStructuredTextEditor) textEditor;
 		IReconciler reconciler = testTextEditor.textViewerConfiguration.getReconciler(testTextEditor.getTextViewer());

 		assertNotNull(reconciler);
 		assertTrue("unexpected IReconciler implementation: " + reconciler.getClass(), reconciler instanceof DocumentRegionProcessor);

 		Class reconcilerClass = reconciler.getClass();
 		Method method = null;
 		while (reconcilerClass != Object.class && method == null) {
 			Method[] methods = reconcilerClass.getDeclaredMethods();
 			for (int i = 0; i < methods.length; i++) {
 				if (methods[i].getName().equals("getValidatorStrategy")) {
 					method = methods[i];
 				}
 			}
 			reconcilerClass = reconcilerClass.getSuperclass();
 		}

 		assertNotNull("no getValidatorStrategy method found on " + reconciler.getClass(), method);
 		method.setAccessible(true);
 		ValidatorStrategy strategy = (ValidatorStrategy) method.invoke(reconciler, new Object[0]);
 		assertNotNull(strategy);
 		Field fMetaData = strategy.getClass().getDeclaredField("fMetaData");
 		assertNotNull("validator metadata field \"fMetaData\" not found on strategy " + strategy.getClass(), fMetaData);
 		fMetaData.setAccessible(true);
 		List metadata = (List) fMetaData.get(strategy);
 		assertNotNull(metadata);
 		for (int i = 0; i < metadata.size(); i++) {
 			validatorIds.add(((ValidatorMetaData) metadata.get(i)).getValidatorId());
 		}

 		page.closeEditor(editor, false);

 		return validatorIds;
 	}

 	protected void setUp() throws Exception {
 		ensureProjectIsAccessible(PROJECT_NAME);

 		// turn on reconciling
 		IPreferenceStore store = SSEUIPlugin.getDefault().getPreferenceStore();
 		fPreviousReconcilerPref = store.getBoolean(CommonEditorPreferenceNames.EVALUATE_TEMPORARY_PROBLEMS);
 		if (!fPreviousReconcilerPref) {
 			store.setValue(CommonEditorPreferenceNames.EVALUATE_TEMPORARY_PROBLEMS, true);
 		}
 	}

 	protected void tearDown() throws Exception {
 		// restore reconciling preference
 		IPreferenceStore store = SSEUIPlugin.getDefault().getPreferenceStore();
 		store.setValue(CommonEditorPreferenceNames.EVALUATE_TEMPORARY_PROBLEMS, fPreviousReconcilerPref);
 	}

 	public void testSourceValidationEnablementWithInheritedValidators() throws Exception {
 		Object[] xmlValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xml").toArray();
 		assertTrue("No XML source validators found", xmlValidatorIDs.length > 0);
 		Object[] xml99ValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xml99").toArray();
 		assertTrue("No XML99 source validators found", xml99ValidatorIDs.length > 0);

 		Arrays.sort(xmlValidatorIDs);
 		Arrays.sort(xml99ValidatorIDs);

 		assertEquals("validator lists should be the same length", xmlValidatorIDs.length, xml99ValidatorIDs.length);
 		for (int i = 0; i < xmlValidatorIDs.length; i++) {
 			assertEquals("validator IDs should be the same [" + i + "]", xmlValidatorIDs[i], xml99ValidatorIDs[i]);
 		}
 	}

 	public void testSourceValidationEnablementWithUniqueValidators() throws Exception {
 		String[] xmlContentTypes = detectContentTypeIDs("testValidatorConfigurations.xml");
 		String[] xsdContentTypes = detectContentTypeIDs("testValidatorConfigurations.xsd");

 		/*
 		 * If the current configuration does not include a distinct XSD
 		 * content type, skip the rest
 		 */
 		if (!identicalContents(xmlContentTypes, xsdContentTypes)) {
 			List xmlValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xml");
 			assertTrue("No XML source validators found", !xmlValidatorIDs.isEmpty());
 			List xsdValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xsd");
 			assertTrue("No XSD source validators found", !xsdValidatorIDs.isEmpty());
 			for (int i = 0; i < xmlValidatorIDs.size(); i++) {
 				assertTrue("XML Validator found on XSD input", !xsdValidatorIDs.contains(xmlValidatorIDs.get(i)));
 			}
 		}
 		else {
 			String message = "No distinct XSD content type found while running " + getClass().getName();
 			System.err.println(message);
 			Logger.log(Logger.WARNING, message);
 		}
 	}

 	public void testSourceValidationEnablementWithUnrelatedContentTypes() throws Exception {
 		String[] dtdContentTypes = detectContentTypeIDs("testValidatorConfigurations.dtd");
 		String[] jspContentTypes = detectContentTypeIDs("testValidatorConfigurations.jsp");
 		if (dtdContentTypes.length == 0) {
 			String message = "No DTD content type found while running " + getClass().getName();
 			System.err.println(message);
 			Logger.log(Logger.WARNING, message);
 		}
 		if (jspContentTypes.length == 0) {
 			String message = "No JSP content type found while running " + getClass().getName();
 			System.err.println(message);
 			Logger.log(Logger.WARNING, message);
 		}


 		if (dtdContentTypes.length > 0 && jspContentTypes.length > 0 && !identicalContents(dtdContentTypes, jspContentTypes)) {
 			List dtdValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.dtd");
 			assertTrue("No DTD source validators found", !dtdValidatorIDs.isEmpty());
 			List jspValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.jsp");
 			assertTrue("No JSP source validators found", !jspValidatorIDs.isEmpty());
 			int dtdValidatorCount = dtdValidatorIDs.size();
 			dtdValidatorIDs.removeAll(jspValidatorIDs);
 			assertEquals("validators found running on both CSS and DTD", dtdValidatorCount, dtdValidatorIDs.size());
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2006 IBM Corporation 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:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.wst.xml.ui.tests;

	import java.io.ByteArrayInputStream;
	import java.lang.reflect.Field;
	import java.lang.reflect.Method;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;

	import junit.framework.TestCase;

	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IProjectDescription;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.core.runtime.content.IContentDescription;
	import org.eclipse.core.runtime.content.IContentType;
	import org.eclipse.jface.preference.IPreferenceStore;
	import org.eclipse.jface.text.reconciler.IReconciler;
	import org.eclipse.jface.text.source.SourceViewerConfiguration;
	import org.eclipse.ui.IEditorPart;
	import org.eclipse.ui.IWorkbenchPage;
	import org.eclipse.ui.IWorkbenchWindow;
	import org.eclipse.ui.PlatformUI;
	import org.eclipse.ui.ide.IDE;
	import org.eclipse.ui.texteditor.ITextEditor;
	import org.eclipse.wst.sse.ui.StructuredTextEditor;
	import org.eclipse.wst.sse.ui.internal.SSEUIPlugin;
	import org.eclipse.wst.sse.ui.internal.provisional.preferences.CommonEditorPreferenceNames;
	import org.eclipse.wst.sse.ui.internal.reconcile.DocumentRegionProcessor;
	import org.eclipse.wst.sse.ui.internal.reconcile.validator.ValidatorMetaData;
	import org.eclipse.wst.sse.ui.internal.reconcile.validator.ValidatorStrategy;

	/**
	* Tests reconciler in an open editor. The location of this class is awkward
	* in that it refers to content types declared in plugins that aren't required
	* to be present.
	*/
	public class TestSourceValidationFramework extends TestCase {
	/**
	* THIS SUBCLASS IS FOR TESTING ONLY
	*/
	public static class TestStructuredTextEditor extends StructuredTextEditor {
	public SourceViewerConfiguration textViewerConfiguration = null;

	protected void setSourceViewerConfiguration(SourceViewerConfiguration config) {
	super.setSourceViewerConfiguration(config);
	textViewerConfiguration = config;
	}
	}

	private static final String PROJECT_NAME = "TestSourceValidationFramework";

	private static final String SEPARATOR = String.valueOf(IPath.SEPARATOR);

	private boolean fPreviousReconcilerPref;

	public TestSourceValidationFramework() {
	super("TestSourceValidationFramework");
	}

	private IFile ensureFileIsAccessible(String filePath, byte[] contents) {
	IFile blankFile = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(filePath));
	if (blankFile != null && !blankFile.isAccessible()) {
	try {
	byte[] bytes = contents;
	if (bytes == null) {
	bytes = new byte[0];
	}
	blankFile.create(new ByteArrayInputStream(bytes), true, new NullProgressMonitor());
	}
	catch (CoreException e) {
	e.printStackTrace();
	}
	}
	return blankFile;
	}

	private IContentType[] detectContentTypes(String fileName) {
	IContentType[] types = null;
	IFile file = ensureFileIsAccessible(PROJECT_NAME + SEPARATOR + fileName, null);

	types = Platform.getContentTypeManager().findContentTypesFor(file.getName());
	if (types.length == 0) {
	IContentDescription d = null;
	try {
	// optimized description lookup, might not succeed
	d = file.getContentDescription();
	if (d != null) {
	types = new IContentType[]{d.getContentType()};
	}
	}
	catch (CoreException e) {
	/*
	* should not be possible given the accessible and file type
	* check above
	*/
	}
	}
	if (types == null) {
	types = Platform.getContentTypeManager().findContentTypesFor(file.getName());
	}
	return types;
	}

	private String[] detectContentTypeIDs(String fileName) {
	IContentType[] types = detectContentTypes(fileName);
	String[] ids = new String[types.length];
	for (int i = 0; i < types.length; i++) {
	ids[i] = types[i].getId();
	}
	return ids;
	}

	private boolean identicalContents(Object o1[], Object o2[]) {
	if (o1.length == 0 && o2.length == 0)
	return true;

	Object[] array1 = new Object[o1.length];
	Object[] array2 = new Object[o2.length];
	System.arraycopy(o1, 0, array1, 0, o1.length);
	System.arraycopy(o2, 0, array2, 0, o2.length);
	Arrays.sort(array1);
	Arrays.sort(array2);
	return Arrays.equals(array1, array2);
	}


	private void ensureProjectIsAccessible(String projName) {
	IProjectDescription description = ResourcesPlugin.getWorkspace().newProjectDescription(projName);

	IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projName);
	try {
	if (!project.exists())
	project.create(description, new NullProgressMonitor());
	if (!project.isAccessible())
	project.open(new NullProgressMonitor());
	}
	catch (CoreException e) {
	e.printStackTrace();
	}
	}

	private List getSourceValidatorIDs(String fileName) throws Exception {
	List validatorIds = new ArrayList(1);
	IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
	IWorkbenchPage page = workbenchWindow.getActivePage();

	IFile file = ensureFileIsAccessible(PROJECT_NAME + SEPARATOR + fileName, null);
	IEditorPart editor = IDE.openEditor(page, file, TestStructuredTextEditor.class.getName(), true);

	ITextEditor textEditor = (ITextEditor) editor.getAdapter(ITextEditor.class);
	TestStructuredTextEditor testTextEditor = (TestStructuredTextEditor) textEditor;
	IReconciler reconciler = testTextEditor.textViewerConfiguration.getReconciler(testTextEditor.getTextViewer());

	assertNotNull(reconciler);
	assertTrue("unexpected IReconciler implementation: " + reconciler.getClass(), reconciler instanceof DocumentRegionProcessor);

	Class reconcilerClass = reconciler.getClass();
	Method method = null;
	while (reconcilerClass != Object.class && method == null) {
	Method[] methods = reconcilerClass.getDeclaredMethods();
	for (int i = 0; i < methods.length; i++) {
	if (methods[i].getName().equals("getValidatorStrategy")) {
	method = methods[i];
	}
	}
	reconcilerClass = reconcilerClass.getSuperclass();
	}

	assertNotNull("no getValidatorStrategy method found on " + reconciler.getClass(), method);
	method.setAccessible(true);
	ValidatorStrategy strategy = (ValidatorStrategy) method.invoke(reconciler, new Object[0]);
	assertNotNull(strategy);
	Field fMetaData = strategy.getClass().getDeclaredField("fMetaData");
	assertNotNull("validator metadata field \"fMetaData\" not found on strategy " + strategy.getClass(), fMetaData);
	fMetaData.setAccessible(true);
	List metadata = (List) fMetaData.get(strategy);
	assertNotNull(metadata);
	for (int i = 0; i < metadata.size(); i++) {
	validatorIds.add(((ValidatorMetaData) metadata.get(i)).getValidatorId());
	}

	page.closeEditor(editor, false);

	return validatorIds;
	}

	protected void setUp() throws Exception {
	ensureProjectIsAccessible(PROJECT_NAME);

	// turn on reconciling
	IPreferenceStore store = SSEUIPlugin.getDefault().getPreferenceStore();
	fPreviousReconcilerPref = store.getBoolean(CommonEditorPreferenceNames.EVALUATE_TEMPORARY_PROBLEMS);
	if (!fPreviousReconcilerPref) {
	store.setValue(CommonEditorPreferenceNames.EVALUATE_TEMPORARY_PROBLEMS, true);
	}
	}

	protected void tearDown() throws Exception {
	// restore reconciling preference
	IPreferenceStore store = SSEUIPlugin.getDefault().getPreferenceStore();
	store.setValue(CommonEditorPreferenceNames.EVALUATE_TEMPORARY_PROBLEMS, fPreviousReconcilerPref);
	}

	public void testSourceValidationEnablementWithInheritedValidators() throws Exception {
	Object[] xmlValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xml").toArray();
	assertTrue("No XML source validators found", xmlValidatorIDs.length > 0);
	Object[] xml99ValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xml99").toArray();
	assertTrue("No XML99 source validators found", xml99ValidatorIDs.length > 0);

	Arrays.sort(xmlValidatorIDs);
	Arrays.sort(xml99ValidatorIDs);

	assertEquals("validator lists should be the same length", xmlValidatorIDs.length, xml99ValidatorIDs.length);
	for (int i = 0; i < xmlValidatorIDs.length; i++) {
	assertEquals("validator IDs should be the same [" + i + "]", xmlValidatorIDs[i], xml99ValidatorIDs[i]);
	}
	}

	public void testSourceValidationEnablementWithUniqueValidators() throws Exception {
	String[] xmlContentTypes = detectContentTypeIDs("testValidatorConfigurations.xml");
	String[] xsdContentTypes = detectContentTypeIDs("testValidatorConfigurations.xsd");

	/*
	* If the current configuration does not include a distinct XSD
	* content type, skip the rest
	*/
	if (!identicalContents(xmlContentTypes, xsdContentTypes)) {
	List xmlValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xml");
	assertTrue("No XML source validators found", !xmlValidatorIDs.isEmpty());
	List xsdValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xsd");
	assertTrue("No XSD source validators found", !xsdValidatorIDs.isEmpty());
	for (int i = 0; i < xmlValidatorIDs.size(); i++) {
	assertTrue("XML Validator found on XSD input", !xsdValidatorIDs.contains(xmlValidatorIDs.get(i)));
	}
	}
	else {
	String message = "No distinct XSD content type found while running " + getClass().getName();
	System.err.println(message);
	Logger.log(Logger.WARNING, message);
	}
	}

	public void testSourceValidationEnablementWithUnrelatedContentTypes() throws Exception {
	String[] dtdContentTypes = detectContentTypeIDs("testValidatorConfigurations.dtd");
	String[] jspContentTypes = detectContentTypeIDs("testValidatorConfigurations.jsp");
	if (dtdContentTypes.length == 0) {
	String message = "No DTD content type found while running " + getClass().getName();
	System.err.println(message);
	Logger.log(Logger.WARNING, message);
	}
	if (jspContentTypes.length == 0) {
	String message = "No JSP content type found while running " + getClass().getName();
	System.err.println(message);
	Logger.log(Logger.WARNING, message);
	}


	if (dtdContentTypes.length > 0 && jspContentTypes.length > 0 && !identicalContents(dtdContentTypes, jspContentTypes)) {
	List dtdValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.dtd");
	assertTrue("No DTD source validators found", !dtdValidatorIDs.isEmpty());
	List jspValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.jsp");
	assertTrue("No JSP source validators found", !jspValidatorIDs.isEmpty());
	int dtdValidatorCount = dtdValidatorIDs.size();
	dtdValidatorIDs.removeAll(jspValidatorIDs);
	assertEquals("validators found running on both CSS and DTD", dtdValidatorCount, dtdValidatorIDs.size());
	}
	}
	}