tests/org.eclipse.jst.j2ee.core.tests/commonArchiveTests/org/eclipse/jst/j2ee/archive/emftests/GeneralEMFEditingTest.java - jeetools/webtools.javaee.tests - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2007 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.jst.j2ee.archive.emftests;

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.LineNumberReader;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.emf.ecore.EAttribute;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.jem.java.JavaRefPackage;
 import org.eclipse.jem.java.internal.impl.JavaClassImpl;
 import org.eclipse.jst.j2ee.archive.testutilities.EMFAttributeFeatureGenerator;
 import org.eclipse.jst.j2ee.archive.testutilities.J2EEVersionCheck;
 import org.eclipse.jst.j2ee.archive.testutilities.TestUtilities;
 import org.eclipse.jst.j2ee.common.CommonPackage;
 import org.eclipse.jst.j2ee.core.tests.bvt.AutomatedBVT;
 import org.eclipse.wst.common.internal.emf.resource.RendererFactory;


 public class GeneralEMFEditingTest extends GeneralEMFTest {
 	//inner class to handle deffered shared references
 	protected class DeferredSharedReferenceAction {
 		EObject owner;
 		EReference ref;

 		public DeferredSharedReferenceAction(EObject owner, EReference ref) {
 			this.owner = owner;
 			this.ref = ref;
 		}

 		public void performAction() {
 			Object value = getSharedObjectByType(owner, ref);
 			setReferenceValue(owner, ref, value);
 		}
 	}

 	protected Map equivalentLines;
 	public List deferedReferences;
 	public static int genDepth = 5;
 	public static Object sharedValue;
 	public int classIndex = 0;
 	public static String avClass[];
 	public static HashSet ignoreAtt;

 	public int version;
 	public int moduleType;
 	//static versions
 	public static final int VERSION_1_2 = 0;
 	public static final int VERSION_1_3 = 1;
 	public static final int VERSION_1_4 = 2;

 	public static final int APPICATION = 0;
 	public static final int APP_CLIENT = 1;
 	public static final int CONNECTOR = 2;
 	public static final int EJB = 3;
 	public static final int WEB = 4;

 	public GeneralEMFEditingTest(String name) {
 		super(name);
 	}

     public GeneralEMFEditingTest(String name, RendererFactory factory) {
     	super(name, factory);
     }

 	public void editRoot(EObject eObject) {
 		editFeatures(eObject);
 		//if (deferedReferences != null) {
 		//	for (int i = 0; i < deferedReferences.size(); i++) {
 		//		((DeferredSharedReferenceAction) deferedReferences.get(i)).performAction();
 		//	}
 		//}
 	}

 	public void editFeatures(EObject eObject) {
 		if (eObject == null)
 			return;
 		else {
 			editAttributes(eObject);
 			editReferences(eObject);
 		}
 	}

 	protected void editReferences(EObject eObject) {
 		List references = eObject.eClass().getEAllReferences();
 		for (int i = 0; i < references.size(); i++) {
 			EReference ref = (EReference) references.get(i);
 			if (!ref.isMany() && eObject.eGet(ref) != null)
 				continue;
 			if (ref.isContainment())
 				populateContainmentReference(eObject, ref);
 			else
 				populateSharedReference(eObject, ref);
 		}
 	}

 	protected void populateSharedReference(EObject eObject, EReference ref) {
 		if (ref.getEType() == JavaRefPackage.eINSTANCE.getJavaClass())
 			setReferenceValue(eObject, ref, createJavaClassProxy((EClass) ref.getEType()));
 		else {
 			EPackage pkg = ref.getEType().getEPackage();
 			if (pkg == eObject.eClass().getEPackage() || pkg == CommonPackage.eINSTANCE) {
 				if (eObject.eClass().getName().equals("EAnnotation") || eObject.eClass().getName().equals("EAnnotationImpl") || !J2EEVersionCheck.checkReferenceVersion(ref, version, moduleType))
 					return;
 				if (deferedReferences == null)
 					deferedReferences = new ArrayList();
 				deferedReferences.add(new DeferredSharedReferenceAction(eObject, ref));
 			}
 		}
 	}

 	protected void populateContainmentReference(EObject eObject, EReference ref) {
 		for (int i = 0; i < getDepthForAttribute(ref); i++) {
 			EObject instance = createInstance((EClass) ref.getEType());
 			if (instance == null)
 				return;
 			if (!J2EEVersionCheck.checkReferenceVersion(ref, version, moduleType))
 				continue;
 			setReferenceValue(eObject, ref, instance);
 			if (((InternalEObject) instance).eIsProxy())
 				return;
 			if (ref.getEType() == eObject.eClass())
 				editAttributes(instance);
 			else
 				editFeatures(instance);
 		}
 	}

 	protected void setReferenceValue(EObject eObject, EReference ref, Object value) {
 		if (ref.getName().equals("EAnnotation") || ref.getName().equals("EAnnotationImpl") || !J2EEVersionCheck.checkReferenceVersion(ref, version, moduleType))
 			return;
 		if (ref.isMany()) {
 			List list = (List) eObject.eGet(ref);
 			if (value instanceof Collection)
 				list.addAll((Collection) value);
 			else
 				list.add(value);
 		} else {
 			eObject.eSet(ref, value);
 		}
 	}

 	public EObject createInstance(EClass eClassifier) {
 		if (eClassifier == JavaRefPackage.eINSTANCE.getJavaClass())
 			return createJavaClassProxy(eClassifier);
 		return eClassifier.getEPackage().getEFactoryInstance().create(eClassifier);
 	}

 	protected void editAttributes(EObject eObject) {
 		List attributes = eObject.eClass().getEAllAttributes();
 		for (int i = 0; i < attributes.size(); i++) {
 			EAttribute att = (EAttribute) attributes.get(i);
 			if (att.isChangeable() && J2EEVersionCheck.checkAttributeVersion(att, version, moduleType)) {
 				Object value = createAttributeValue(att, eObject);
 				eObject.eSet(att, value);
 			}
 		}
 	}

 	protected Object createAttributeValue(EAttribute att, EObject eObject) {
 		if (att.getEType() == JavaRefPackage.eINSTANCE.getJavaClass()) {
 			return createJavaClassProxy(att.eClass()).getClass();
 		}
 		// if (moduleType == WEB)
 			return EMFAttributeFeatureGenerator.createAttribute(att, eObject, true, version, moduleType);
 		//return EMFAttributeFeatureGenerator.createAttribute(att);
 	}

 	protected EObject createJavaClassProxy(EClass metaClass) {
 		if (avClass == null) {
 			avClass = new String[] { "java.util.HashTable", "java.util.List", "java.sql.Data", "java.lang.Integer", "java.lang.String" };
 		}
 		String name = avClass[classIndex];
 		classIndex++;
 		if (classIndex == 5)
 			classIndex = 0;
 		return JavaClassImpl.createClassRef(name);
 	}

 	// Old Compare method....now using DOMComparator...remove once stable
 	public void compareContents(String file1, String file2) throws Exception {
 	    BufferedReader reader1 = null;
 	    BufferedReader reader2 = null;
 		try {
 			int lineno = 1;
 			reader1 = new BufferedReader(new InputStreamReader(getFileInputStream(file1)));
 			reader2 = new BufferedReader(new InputStreamReader(getFileInputStream(file2)));
 			String line1 = "", line2 = "";
 			while (reader1.ready() && reader2.ready()) {
 				line1 = readLineTrimComments(reader1);
 				line2 = readLineTrimComments(reader2);
 				if (line1 == null && line2 == null && lineno != 0)
 					return;

 				if (!line1.trim().equals(line2.trim())) {
 					String message = "Error at line #: " + lineno + '\n' + line1 + '\n' + line2 + '\n';
 					System.out.println(message);
 					//assertTrue(message, false);
 				}
 				lineno++;
 			}
 			assertTrue("The files have a different number of lines:" + lineno + '\n' + line1 + '\n' + line2 + '\n', (!reader1.ready() && !reader2.ready()));
 		} catch (IOException ex) {
 		    ex.printStackTrace();
 			assertTrue("IO failed", false);
 		} finally {
 		    if(reader1 != null)
 		        reader1.close();
 		    if(reader2 != null)
 		        reader2.close();
 		}
 	}

     /**
      * @param string
      * @return
      */
     private String readLineTrimComments(BufferedReader reader) throws IOException {
         String result = reader.readLine();
         if(result.indexOf("<!--") < 0)
             return result;
         else {
             int endCommentIndx = 0;
             while(reader.ready()) {
                 if( (endCommentIndx = result.indexOf("-->")) >= 0)
                     result = reader.readLine();
                 else
                     return result;
             }
         }
         return result;
     }

     public void compareContentsIgnoreWhitespace(String file1, String file2, String identifier) throws Exception {

 		LineNumberReader reader1 = new LineNumberReader(new InputStreamReader(getFileInputStream(file1)));
 		LineNumberReader reader2 = new LineNumberReader(new InputStreamReader(getFileInputStream(file2)));
 		compareContentsIgnoreWhitespace(reader1, reader2, identifier);

 	}

 	public void compareContentsIgnoreWhitespace(LineNumberReader reader1, LineNumberReader reader2, String identifier) throws Exception {

 		while (reader1.ready() || reader2.ready()) {
 			String line1 = "", line2 = "";
 			while (reader1.ready() && line1.equals("")) {
 				line1 = reader1.readLine().trim();
 			}
 			while (reader2.ready() && line2.equals("")) {
 				line2 = reader2.readLine().trim();
 			}
 			if (!isEquivalentLines(line1, line2)) {
 				StringBuffer buff = new StringBuffer();
 				buff.append("Difference found in test ");

 				buff.append(identifier);
 				buff.append("\nSource line #: ");
 				buff.append(reader1.getLineNumber());
 				buff.append('\n');
 				buff.append(line1);
 				buff.append("\nDestination line #: ");
 				buff.append(reader2.getLineNumber());
 				buff.append('\n');
 				buff.append(line2);
 				assertTrue(buff.toString(), false);
 			}
 		}

 	}

 	public boolean lineEquals(String line1, String line2) {
 		return line1.equals(line2);
 	}

 	public boolean isEquivalentLines(String line1, String line2) {
 		if (lineEquals(line1, line2))
 			return true;
 		if (equalTags(line1, line2))
 			return true;
 		String equiv = (String) getEquivalentLines().get(line1);
 		return equiv != null && equiv.equals(line2);
 	}

 	public boolean equalTags(String line1, String line2){
 		//data check, there should be no data for this test to return true
 		int shortEndIndex1 = line1.indexOf("/>");
 		int shortEndIndex2 = line2.indexOf("/>");
 		if (shortEndIndex1 == -1 && shortEndIndex2 == -1)
 			return false;
 		else if (shortEndIndex1 != -1){
 			String tagName1 = line1.substring(1,shortEndIndex1);
 			String tagName2 = extractTagName(line2);
 			if (checkNoData(line2) && tagName1.equals(tagName2)){
 				return true;
 			}
 		}
 		else if (shortEndIndex2 != -1){
 			String tagName1 = extractTagName(line1);
 			String tagName2 = line2.substring(1,shortEndIndex2);
 			if (checkNoData(line1) && tagName1.equals(tagName2)){
 				return true;
 			}
 		}
 		return false;
 	}
 	/**
 	 * @param line2
 	 * @return
 	 */
 	private String extractTagName(String line) {
 		int endOpenTag = line.indexOf(">");
 		return line.substring(1,endOpenTag);
 	}

 	/**
 	 * @param line2
 	 * @return
 	 */
 	private boolean checkNoData(String line) {
 		int endOpenTag = line.indexOf(">");
 		int startEndTag = line.lastIndexOf("<");
 		if (endOpenTag == line.length())
 			return true;
 		else if (endOpenTag+1 == startEndTag)
 			return true;
 		return false;
 	}

 	public Map getEquivalentLines() {
 		if (equivalentLines == null)
 			equivalentLines = new HashMap();
 		return equivalentLines;
 	}

 	public void setEquivalentLines(Map equivalentLines) {
 		this.equivalentLines = equivalentLines;
 	}
 	/*
 		public void compareContents(String file1, String file2) throws Exception {
 			InputStream is1, is2;
 			is1 = getFileInputStream(file1);
 			is2 = getFileInputStream(file2);
 			InputSource input1 = new InputSource(is1);
 			InputSource input2 = new InputSource(is2);
 			try {
 				String results;
 				if(ignoreAtt == null)
 					results = DomComparitor.compareDoms(input1, input2);
 				else
 					results = DomComparitor.compareDoms(input1, input2, ignoreAtt);
 				if (results != null) {
 					assertTrue("Unequal doms compared as equal " + file1 + " " + file2 + "Details: " + results, false);
 				}
 			} finally {
 				try {
 					is1.close();
 				} catch (Exception e) {
 					Assert.fail(e.getMessage());
 				}
 				try {
 					is2.close();
 				} catch (Exception e) {
 					Assert.fail(e.getMessage());
 				}
 			}
 		}
 	*/
 	public InputStream getFileInputStream(String path) throws FileNotFoundException {
 		return new FileInputStream(path);
 	}

 	public InputStream getResourceAsStream(String fileName) {
 		InputStream in = null;
 		ClassLoader loader = getClass().getClassLoader();
 		if (loader == null) {
 			in = ClassLoader.getSystemResourceAsStream(fileName);
 		} else {
 			in = loader.getResourceAsStream(fileName);
 		}
 		assertTrue("Unable to find resource: " + fileName, in != null);
 		return in;
 	}

 	public void setGeneralDepth(int depth) {
 		GeneralEMFPopulationTest.genDepth = depth;
 	}

 	public void setModuleType(int type) {
 		moduleType = type;
 	}

 	public void setVersion(int version) {
 		this.version = version;
 	}

 	public int getDepthForAttribute(EReference ref) {
 		if (ref.isMany())
 			return genDepth;
 		else
 			return 1;
 	}

 	public Object getSharedObjectByType(EObject owner, EReference ref) {
 		sharedValue = TestUtilities.getObjectByType(owner.eResource(), ref.getEType(), ref.isMany());
 		return sharedValue;
 	}

 	/**
 	 * @param set
 	 */
 	public static void setIgnoreAtt(HashSet set) {
 		ignoreAtt = set;
 	}

 	/* (non-Javadoc)
 	 * @see junit.framework.TestCase#tearDown()
 	 */
 	protected void tearDown() throws Exception {
 		try {
 			String out = AutomatedBVT.baseDirectory + "testOutput/";
 			File del = new File(out);
 			deleteDirectory(del);
 			del.delete();
 			out = AutomatedBVT.baseDirectory + "../testData/testOutput/";
 			del = new File(out);
 			deleteDirectory(del);
 			del.delete();
 		}
 		catch (Exception e){
 			e.printStackTrace();
 		}
 		super.tearDown();
 	}

 	protected void deleteDirectory(File directory)
 	   throws IOException
 	{
 		if (directory.exists()){
 		   File[] delFiles = directory.listFiles();

 		   for(int i=0; i<delFiles.length; ++i)
 		   {
 		      if(delFiles[i].isDirectory())
 		         deleteDirectory(delFiles[i]);
 		      delFiles[i].delete();
 		   }
 		}
 	}

 	protected void setUp() throws Exception {
 		super.setUp();
 		//TODO: Remove this line after ws xsd's are restored.
 		RendererFactory.getDefaultRendererFactory().setValidating(false);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2007 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.jst.j2ee.archive.emftests;

	import java.io.BufferedReader;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.LineNumberReader;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.emf.ecore.EAttribute;
	import org.eclipse.emf.ecore.EClass;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.EPackage;
	import org.eclipse.emf.ecore.EReference;
	import org.eclipse.emf.ecore.InternalEObject;
	import org.eclipse.jem.java.JavaRefPackage;
	import org.eclipse.jem.java.internal.impl.JavaClassImpl;
	import org.eclipse.jst.j2ee.archive.testutilities.EMFAttributeFeatureGenerator;
	import org.eclipse.jst.j2ee.archive.testutilities.J2EEVersionCheck;
	import org.eclipse.jst.j2ee.archive.testutilities.TestUtilities;
	import org.eclipse.jst.j2ee.common.CommonPackage;
	import org.eclipse.jst.j2ee.core.tests.bvt.AutomatedBVT;
	import org.eclipse.wst.common.internal.emf.resource.RendererFactory;


	public class GeneralEMFEditingTest extends GeneralEMFTest {
	//inner class to handle deffered shared references
	protected class DeferredSharedReferenceAction {
	EObject owner;
	EReference ref;

	public DeferredSharedReferenceAction(EObject owner, EReference ref) {
	this.owner = owner;
	this.ref = ref;
	}

	public void performAction() {
	Object value = getSharedObjectByType(owner, ref);
	setReferenceValue(owner, ref, value);
	}
	}

	protected Map equivalentLines;
	public List deferedReferences;
	public static int genDepth = 5;
	public static Object sharedValue;
	public int classIndex = 0;
	public static String avClass[];
	public static HashSet ignoreAtt;

	public int version;
	public int moduleType;
	//static versions
	public static final int VERSION_1_2 = 0;
	public static final int VERSION_1_3 = 1;
	public static final int VERSION_1_4 = 2;

	public static final int APPICATION = 0;
	public static final int APP_CLIENT = 1;
	public static final int CONNECTOR = 2;
	public static final int EJB = 3;
	public static final int WEB = 4;

	public GeneralEMFEditingTest(String name) {
	super(name);
	}

	public GeneralEMFEditingTest(String name, RendererFactory factory) {
	super(name, factory);
	}

	public void editRoot(EObject eObject) {
	editFeatures(eObject);
	//if (deferedReferences != null) {
	// for (int i = 0; i < deferedReferences.size(); i++) {
	// ((DeferredSharedReferenceAction) deferedReferences.get(i)).performAction();
	// }
	//}
	}

	public void editFeatures(EObject eObject) {
	if (eObject == null)
	return;
	else {
	editAttributes(eObject);
	editReferences(eObject);
	}
	}

	protected void editReferences(EObject eObject) {
	List references = eObject.eClass().getEAllReferences();
	for (int i = 0; i < references.size(); i++) {
	EReference ref = (EReference) references.get(i);
	if (!ref.isMany() && eObject.eGet(ref) != null)
	continue;
	if (ref.isContainment())
	populateContainmentReference(eObject, ref);
	else
	populateSharedReference(eObject, ref);
	}
	}

	protected void populateSharedReference(EObject eObject, EReference ref) {
	if (ref.getEType() == JavaRefPackage.eINSTANCE.getJavaClass())
	setReferenceValue(eObject, ref, createJavaClassProxy((EClass) ref.getEType()));
	else {
	EPackage pkg = ref.getEType().getEPackage();
	if (pkg == eObject.eClass().getEPackage() \|\| pkg == CommonPackage.eINSTANCE) {
	if (eObject.eClass().getName().equals("EAnnotation") \|\| eObject.eClass().getName().equals("EAnnotationImpl") \|\| !J2EEVersionCheck.checkReferenceVersion(ref, version, moduleType))
	return;
	if (deferedReferences == null)
	deferedReferences = new ArrayList();
	deferedReferences.add(new DeferredSharedReferenceAction(eObject, ref));
	}
	}
	}

	protected void populateContainmentReference(EObject eObject, EReference ref) {
	for (int i = 0; i < getDepthForAttribute(ref); i++) {
	EObject instance = createInstance((EClass) ref.getEType());
	if (instance == null)
	return;
	if (!J2EEVersionCheck.checkReferenceVersion(ref, version, moduleType))
	continue;
	setReferenceValue(eObject, ref, instance);
	if (((InternalEObject) instance).eIsProxy())
	return;
	if (ref.getEType() == eObject.eClass())
	editAttributes(instance);
	else
	editFeatures(instance);
	}
	}

	protected void setReferenceValue(EObject eObject, EReference ref, Object value) {
	if (ref.getName().equals("EAnnotation") \|\| ref.getName().equals("EAnnotationImpl") \|\| !J2EEVersionCheck.checkReferenceVersion(ref, version, moduleType))
	return;
	if (ref.isMany()) {
	List list = (List) eObject.eGet(ref);
	if (value instanceof Collection)
	list.addAll((Collection) value);
	else
	list.add(value);
	} else {
	eObject.eSet(ref, value);
	}
	}

	public EObject createInstance(EClass eClassifier) {
	if (eClassifier == JavaRefPackage.eINSTANCE.getJavaClass())
	return createJavaClassProxy(eClassifier);
	return eClassifier.getEPackage().getEFactoryInstance().create(eClassifier);
	}

	protected void editAttributes(EObject eObject) {
	List attributes = eObject.eClass().getEAllAttributes();
	for (int i = 0; i < attributes.size(); i++) {
	EAttribute att = (EAttribute) attributes.get(i);
	if (att.isChangeable() && J2EEVersionCheck.checkAttributeVersion(att, version, moduleType)) {
	Object value = createAttributeValue(att, eObject);
	eObject.eSet(att, value);
	}
	}
	}

	protected Object createAttributeValue(EAttribute att, EObject eObject) {
	if (att.getEType() == JavaRefPackage.eINSTANCE.getJavaClass()) {
	return createJavaClassProxy(att.eClass()).getClass();
	}
	// if (moduleType == WEB)
	return EMFAttributeFeatureGenerator.createAttribute(att, eObject, true, version, moduleType);
	//return EMFAttributeFeatureGenerator.createAttribute(att);
	}

	protected EObject createJavaClassProxy(EClass metaClass) {
	if (avClass == null) {
	avClass = new String[] { "java.util.HashTable", "java.util.List", "java.sql.Data", "java.lang.Integer", "java.lang.String" };
	}
	String name = avClass[classIndex];
	classIndex++;
	if (classIndex == 5)
	classIndex = 0;
	return JavaClassImpl.createClassRef(name);
	}

	// Old Compare method....now using DOMComparator...remove once stable
	public void compareContents(String file1, String file2) throws Exception {
	BufferedReader reader1 = null;
	BufferedReader reader2 = null;
	try {
	int lineno = 1;
	reader1 = new BufferedReader(new InputStreamReader(getFileInputStream(file1)));
	reader2 = new BufferedReader(new InputStreamReader(getFileInputStream(file2)));
	String line1 = "", line2 = "";
	while (reader1.ready() && reader2.ready()) {
	line1 = readLineTrimComments(reader1);
	line2 = readLineTrimComments(reader2);
	if (line1 == null && line2 == null && lineno != 0)
	return;

	if (!line1.trim().equals(line2.trim())) {
	String message = "Error at line #: " + lineno + '\n' + line1 + '\n' + line2 + '\n';
	System.out.println(message);
	//assertTrue(message, false);
	}
	lineno++;
	}
	assertTrue("The files have a different number of lines:" + lineno + '\n' + line1 + '\n' + line2 + '\n', (!reader1.ready() && !reader2.ready()));
	} catch (IOException ex) {
	ex.printStackTrace();
	assertTrue("IO failed", false);
	} finally {
	if(reader1 != null)
	reader1.close();
	if(reader2 != null)
	reader2.close();
	}
	}

	/**
	* @param string
	* @return
	*/
	private String readLineTrimComments(BufferedReader reader) throws IOException {
	String result = reader.readLine();
	if(result.indexOf("<!--") < 0)
	return result;
	else {
	int endCommentIndx = 0;
	while(reader.ready()) {
	if( (endCommentIndx = result.indexOf("-->")) >= 0)
	result = reader.readLine();
	else
	return result;
	}
	}
	return result;
	}

	public void compareContentsIgnoreWhitespace(String file1, String file2, String identifier) throws Exception {

	LineNumberReader reader1 = new LineNumberReader(new InputStreamReader(getFileInputStream(file1)));
	LineNumberReader reader2 = new LineNumberReader(new InputStreamReader(getFileInputStream(file2)));
	compareContentsIgnoreWhitespace(reader1, reader2, identifier);

	}

	public void compareContentsIgnoreWhitespace(LineNumberReader reader1, LineNumberReader reader2, String identifier) throws Exception {

	while (reader1.ready() \|\| reader2.ready()) {
	String line1 = "", line2 = "";
	while (reader1.ready() && line1.equals("")) {
	line1 = reader1.readLine().trim();
	}
	while (reader2.ready() && line2.equals("")) {
	line2 = reader2.readLine().trim();
	}
	if (!isEquivalentLines(line1, line2)) {
	StringBuffer buff = new StringBuffer();
	buff.append("Difference found in test ");

	buff.append(identifier);
	buff.append("\nSource line #: ");
	buff.append(reader1.getLineNumber());
	buff.append('\n');
	buff.append(line1);
	buff.append("\nDestination line #: ");
	buff.append(reader2.getLineNumber());
	buff.append('\n');
	buff.append(line2);
	assertTrue(buff.toString(), false);
	}
	}

	}

	public boolean lineEquals(String line1, String line2) {
	return line1.equals(line2);
	}

	public boolean isEquivalentLines(String line1, String line2) {
	if (lineEquals(line1, line2))
	return true;
	if (equalTags(line1, line2))
	return true;
	String equiv = (String) getEquivalentLines().get(line1);
	return equiv != null && equiv.equals(line2);
	}

	public boolean equalTags(String line1, String line2){
	//data check, there should be no data for this test to return true
	int shortEndIndex1 = line1.indexOf("/>");
	int shortEndIndex2 = line2.indexOf("/>");
	if (shortEndIndex1 == -1 && shortEndIndex2 == -1)
	return false;
	else if (shortEndIndex1 != -1){
	String tagName1 = line1.substring(1,shortEndIndex1);
	String tagName2 = extractTagName(line2);
	if (checkNoData(line2) && tagName1.equals(tagName2)){
	return true;
	}
	}
	else if (shortEndIndex2 != -1){
	String tagName1 = extractTagName(line1);
	String tagName2 = line2.substring(1,shortEndIndex2);
	if (checkNoData(line1) && tagName1.equals(tagName2)){
	return true;
	}
	}
	return false;
	}
	/**
	* @param line2
	* @return
	*/
	private String extractTagName(String line) {
	int endOpenTag = line.indexOf(">");
	return line.substring(1,endOpenTag);
	}

	/**
	* @param line2
	* @return
	*/
	private boolean checkNoData(String line) {
	int endOpenTag = line.indexOf(">");
	int startEndTag = line.lastIndexOf("<");
	if (endOpenTag == line.length())
	return true;
	else if (endOpenTag+1 == startEndTag)
	return true;
	return false;
	}

	public Map getEquivalentLines() {
	if (equivalentLines == null)
	equivalentLines = new HashMap();
	return equivalentLines;
	}

	public void setEquivalentLines(Map equivalentLines) {
	this.equivalentLines = equivalentLines;
	}
	/*
	public void compareContents(String file1, String file2) throws Exception {
	InputStream is1, is2;
	is1 = getFileInputStream(file1);
	is2 = getFileInputStream(file2);
	InputSource input1 = new InputSource(is1);
	InputSource input2 = new InputSource(is2);
	try {
	String results;
	if(ignoreAtt == null)
	results = DomComparitor.compareDoms(input1, input2);
	else
	results = DomComparitor.compareDoms(input1, input2, ignoreAtt);
	if (results != null) {
	assertTrue("Unequal doms compared as equal " + file1 + " " + file2 + "Details: " + results, false);
	}
	} finally {
	try {
	is1.close();
	} catch (Exception e) {
	Assert.fail(e.getMessage());
	}
	try {
	is2.close();
	} catch (Exception e) {
	Assert.fail(e.getMessage());
	}
	}
	}
	*/
	public InputStream getFileInputStream(String path) throws FileNotFoundException {
	return new FileInputStream(path);
	}

	public InputStream getResourceAsStream(String fileName) {
	InputStream in = null;
	ClassLoader loader = getClass().getClassLoader();
	if (loader == null) {
	in = ClassLoader.getSystemResourceAsStream(fileName);
	} else {
	in = loader.getResourceAsStream(fileName);
	}
	assertTrue("Unable to find resource: " + fileName, in != null);
	return in;
	}

	public void setGeneralDepth(int depth) {
	GeneralEMFPopulationTest.genDepth = depth;
	}

	public void setModuleType(int type) {
	moduleType = type;
	}

	public void setVersion(int version) {
	this.version = version;
	}

	public int getDepthForAttribute(EReference ref) {
	if (ref.isMany())
	return genDepth;
	else
	return 1;
	}

	public Object getSharedObjectByType(EObject owner, EReference ref) {
	sharedValue = TestUtilities.getObjectByType(owner.eResource(), ref.getEType(), ref.isMany());
	return sharedValue;
	}

	/**
	* @param set
	*/
	public static void setIgnoreAtt(HashSet set) {
	ignoreAtt = set;
	}

	/* (non-Javadoc)
	* @see junit.framework.TestCase#tearDown()
	*/
	protected void tearDown() throws Exception {
	try {
	String out = AutomatedBVT.baseDirectory + "testOutput/";
	File del = new File(out);
	deleteDirectory(del);
	del.delete();
	out = AutomatedBVT.baseDirectory + "../testData/testOutput/";
	del = new File(out);
	deleteDirectory(del);
	del.delete();
	}
	catch (Exception e){
	e.printStackTrace();
	}
	super.tearDown();
	}

	protected void deleteDirectory(File directory)
	throws IOException
	{
	if (directory.exists()){
	File[] delFiles = directory.listFiles();

	for(int i=0; i<delFiles.length; ++i)
	{
	if(delFiles[i].isDirectory())
	deleteDirectory(delFiles[i]);
	delFiles[i].delete();
	}
	}
	}

	protected void setUp() throws Exception {
	super.setUp();
	//TODO: Remove this line after ws xsd's are restored.
	RendererFactory.getDefaultRendererFactory().setValidating(false);
	}
	}