1.5/tests/org.eclipse.epf.library.tests/src/org/eclipse/epf/library/tester/impl/TestCommandMgr.java - epf/org.eclipse.epf.composer - Git at Google

 //------------------------------------------------------------------------------
 // Copyright (c) 2005, 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 implementation
 //------------------------------------------------------------------------------
 package org.eclipse.epf.library.tester.impl;

 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.epf.common.utils.XMLUtil;
 import org.eclipse.epf.importing.services.PluginImportingService;
 import org.eclipse.epf.library.project.MethodLibraryProject;
 import org.eclipse.epf.library.tester.LibraryDiffAnalyzor;
 import org.eclipse.epf.library.tester.LibraryTestService;
 import org.eclipse.epf.library.tester.iface.LibraryJunitTest;
 import org.eclipse.epf.library.tester.iface.TCExeReply;
 import org.eclipse.epf.library.tester.iface.TCExeReplyList;
 import org.eclipse.epf.library.tester.iface.TestCommand;
 import org.eclipse.epf.library.tester.iface.TestTracer;
 import org.eclipse.epf.library.tester.impl.testcommands.TCCircularDependencyCheck;
 import org.eclipse.epf.library.tester.impl.testcommands.TCCompareToGoldenFile;
 import org.eclipse.epf.library.tester.impl.testcommands.TCCompareToLibrary;
 import org.eclipse.epf.library.tester.impl.testcommands.TCCopyLibrary;
 import org.eclipse.epf.library.tester.impl.testcommands.TCEditMethodElement;
 import org.eclipse.epf.library.tester.impl.testcommands.TCExeReplyImpl;
 import org.eclipse.epf.library.tester.impl.testcommands.TCExeReplyListImpl;
 import org.eclipse.epf.library.tester.impl.testcommands.TCExportConfiguration;
 import org.eclipse.epf.library.tester.impl.testcommands.TCExportPlugins;
 import org.eclipse.epf.library.tester.impl.testcommands.TCExportXml;
 import org.eclipse.epf.library.tester.impl.testcommands.TCImportConfiguration;
 import org.eclipse.epf.library.tester.impl.testcommands.TCImportPlugins;
 import org.eclipse.epf.library.tester.impl.testcommands.TCImportXml;
 import org.eclipse.epf.library.tester.impl.testcommands.TCNewMethodConfiguration;
 import org.eclipse.epf.library.tester.impl.testcommands.TCNewMethodElement;
 import org.eclipse.epf.library.tester.impl.testcommands.TCNewMethodPlugin;
 import org.eclipse.epf.library.tester.impl.testcommands.TCOpenLibrary;
 import org.eclipse.epf.library.tester.impl.testcommands.TCOutputMethodElement;
 import org.eclipse.epf.library.tests.LibraryTestHelper;
 import org.eclipse.epf.library.util.LibraryUtil;
 import org.eclipse.epf.library.xmi.XMILibraryUtil;
 import org.eclipse.epf.uma.CapabilityPattern;
 import org.eclipse.epf.uma.ContentPackage;
 import org.eclipse.epf.uma.MethodConfiguration;
 import org.eclipse.epf.uma.MethodLibrary;
 import org.eclipse.epf.uma.MethodPlugin;
 import org.eclipse.epf.uma.ProcessComponent;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;

 /**
  * Used in JUnit tests
  *
  * @author Weiping Lu
  * @since 1.0
  *
  */
 public class TestCommandMgr implements TestTracer {

 	//All the tags will be formally specified and read from
 	//a schema later.
 	private static String TCCopyLibrary = "CopyLibrary";
 	private static String TCOpenLibrary = "OpenLibrary";
 	private static String TCExportPlugins = "ExportPlugins";
 	private static String TCImportPlugins = "ImportPlugins";
 	private static String TCExportConfiguration = "ExportConfiguration";
 	private static String TCImportConfiguration = "ImportConfiguration";
 	private static String TCExportXml = "ExportXml";
 	private static String TCImportXml = "ImportXml";
 	private static String TCCompareToLibrary = "CompareToLibrary";
 	private static String TCCompareToGoldenFile = "CompareToGoldenFile";
 	private static String TCNewMethodPlugin = "NewMethodPlugin";
 	private static String TCNewMethodConfiguration = "NewMethodConfiguration";
 	private static String TCNewMethodElement = "NewMethodElement";
 	private static String TCEditMethodElement = "EditMethodElement";
 	private static String TCCircularDependencyCheck = "CircularDependencyCheck";
 	private static String TCEnd = "End";

 	private static String TCEditPlugin="EditPlugin";
 	private static String TCEditConfiguration="EditConfiguration";
 	private static String TCEditContentPackage="EditContentPackage";

 	public static String TCOutputLibrary="OutputLibrary";
 	public static String TCOutputPlugin="OutputPlugin";
 	public static String TCOutputConfiguration="OutputConfiguration";
 	public static String TCOutputMethodElement="OutputMethodElement";

 	private boolean trace = false;
 	private boolean removeFiles = true;

 	private File testRootSource;
 	private File testRootWorking;
 	private File currTestDir;
 	private String outputPath;
 	private Document outputDocument;
 	private PrintStream testRootOut;
 	private PrintStream currTestOut;
 	private int executedTestCount = 0;

 	private static LibraryTestService service = LibraryTestService.getInstance();
 	private File testFile;
 	private List testCommandList = new ArrayList();
 	private LibraryJunitTest junitTestCase;

 	private MethodLibrary currentBaseLib;
 	private Map allLibs = new LinkedHashMap();
 	private Map allExports = new LinkedHashMap();

 	private static Map tcClassMap = new HashMap();
 	private static Map tcTagNameMap = new HashMap();

 	private PrintStream logPS = System.out;

 	static {
 		addToTcClassMap(TCCopyLibrary, TCCopyLibrary.class);
 		addToTcClassMap(TCOpenLibrary, TCOpenLibrary.class);
 		addToTcClassMap(TCExportPlugins, TCExportPlugins.class);
 		addToTcClassMap(TCImportPlugins, TCImportPlugins.class);
 		addToTcClassMap(TCExportConfiguration, TCExportConfiguration.class);
 		addToTcClassMap(TCImportConfiguration, TCImportConfiguration.class);
 		addToTcClassMap(TCExportXml, TCExportXml.class);
 		addToTcClassMap(TCImportXml, TCImportXml.class);
 		addToTcClassMap(TCCompareToLibrary, TCCompareToLibrary.class);
 		addToTcClassMap(TCCompareToGoldenFile, TCCompareToGoldenFile.class);

 		addToTcClassMap(TCNewMethodPlugin, TCNewMethodPlugin.class);
 		addToTcClassMap(TCNewMethodConfiguration, TCNewMethodConfiguration.class);
 		addToTcClassMap(TCNewMethodElement, TCNewMethodElement.class);
 		addToTcClassMap(TCEditMethodElement, TCEditMethodElement.class);

 		addToTcClassMap(TCEditPlugin, TCEditMethodElement.class);
 		addToTcClassMap(TCEditConfiguration, TCEditMethodElement.class);
 		addToTcClassMap(TCEditContentPackage, TCEditMethodElement.class);

 		addToTcClassMap(TCOutputLibrary, TCOutputMethodElement.class);
 		addToTcClassMap(TCOutputPlugin, TCOutputMethodElement.class);
 		addToTcClassMap(TCOutputConfiguration, TCOutputMethodElement.class);
 		addToTcClassMap(TCOutputMethodElement, TCOutputMethodElement.class);
 		addToTcClassMap(TCCircularDependencyCheck, TCCircularDependencyCheck.class);
 	}

 	private static void addToTcClassMap(String elementName, Class cls) {
 		Object instance = null;
 		try {
 			instance = cls.newInstance();
 		} catch (Exception e){
 			e.printStackTrace();
 		}
 		if (instance instanceof TestCommand) {
 			tcClassMap.put(elementName, instance);
 			tcTagNameMap.put(cls, elementName);
 		}
 	}

 	public TestCommandMgr(boolean trace) {
 		if (trace) {
 			this.trace = trace;
 			this.removeFiles = !trace;
 		}
 	}

 	public String getTagName(TestCommand tcInstance) {
 		return (String) tcTagNameMap.get(tcInstance.getClass());
 	}

 	public void setTestRootSource(File dirFile) {
 		testRootSource = dirFile;
 	}

 	public void setTestRootWorking(File dirFile) {
 		boolean needToCreateOutputFile = testRootWorking == null ||
 								! testRootWorking.equals(dirFile);

 		testRootWorking = dirFile;

 		if (trace && needToCreateOutputFile) {
 			try {
 				if (! testRootWorking.exists()) {
 					if (! mkDir(testRootWorking)) {
 						return;
 					}
 				}
 				if (testRootOut != null) {
 					testRootOut.close();
 				}
 				String path = testRootWorking.getAbsolutePath() + File.separator + "traces.out";
 				testRootOut = new PrintStream(new FileOutputStream(path));

 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 	}

 	private boolean mkDir(File file) {
 		File pFile = file.getParentFile();
 		if (! pFile.exists()) {
 			if (! mkDir(pFile)) {
 				return false;
 			}
 		}
 		return file.mkdir();
 	}

 	public void openCurrTestDir(File dirFile) {
 		currTestDir = dirFile;

 		try {
 			if (! currTestDir.exists()) {
 				currTestDir.mkdir();
 			}
 			String path = currTestDir.getAbsolutePath() + File.separator;
 			if (trace) {
 				currTestOut = new PrintStream(new FileOutputStream(path + "trace.out"));
 			}
 			outputPath = path + "output.xml";
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}

 	public void closeCurrTestDir() {
 		closeLibrary(getCurrentBaseLib());
 		if (currTestOut != null) {
 			currTestOut.close();
 			currTestOut = null;
 		}
 		clearOutputDocument();
 		allLibs = new LinkedHashMap();
 		allExports = new LinkedHashMap();
 		closeFolder(currTestDir);
 	}

 	public void doneWithAllTests(File topCleanUpFolder) {
 		closeAllExportProjects();
 		if (testRootOut != null) {
 			testRootOut.close();
 		}
 		closeFolder(topCleanUpFolder);
 	}

 	public File getCurrTestDir() {
 		return currTestDir;
 	}

 	public void setTest(File testFile) {
 		this.testFile = testFile;
 	}

 	public File getTestFile() {
 		return testFile;
 	}


 	public LibraryTestService getService() {
 		return service;
 	}

 	public TCExeReplyList execute() {
 		trace("Begin executing: " + testFile);

 		TCExeReplyList result = null;
 		boolean loaded = false;
 		Exception loadException = null;
 		try {
 			loaded = loadTest();
 		} catch (Exception e) {
 			loadException = e;
 			e.printStackTrace();
 		}

 		if (loaded) {
 			String path = testRootWorking.getAbsolutePath() + File.separator + testFile.getName() + ".dir";
 			openCurrTestDir(new File (path));
 			result = executeCommands();
 			closeCurrTestDir();
 		} else {
 			result = new TCExeReplyListImpl();
 			if (loadException != null) {
 				String msg = "Test load failed: " + loadException.getMessage();
 				((TCExeReplyListImpl) result).add(new TCExeReplyImpl(msg, false));
 				trace(msg);
 			} else {
 				trace("Test disabled");
 			}
 		}

 		trace("End executing  : " + testFile);
 		return result;
 	}

 	private boolean loadTest() throws Exception {
 		testCommandList.clear();
 		Document document = XMLUtil.loadXml(testFile);
 		Element root = document.getDocumentElement();
 		if (root.getAttribute(TestCommand.AT_Disable).equals("true")) {
 			return false;
 		}
 		boolean verbose = root.getAttribute(TestCommand.AT_Verbose).equalsIgnoreCase("true");
 		NodeList nodes = root.getChildNodes();
 		int sz = nodes == null ? 0 : nodes.getLength();
 		for (int i=0; i<sz; i++) {
 			Node node = nodes.item(i);
 			if (node instanceof Element) {
 				Element element = (Element) node;
 				if (verbose) {
 					element.setAttribute(TestCommand.AT_Verbose, "true");
 				}
 				if (element.getTagName().equalsIgnoreCase(TCEnd)) {
 					break;
 				}
 				addCommand(node);
 			}
 		}
 		return true;
 	}

 	public TCExeReplyList executeCommands() {
 		TCExeReplyListImpl result = new TCExeReplyListImpl();
 		for (int i=0; i<testCommandList.size(); i++) {
 			TestCommandImpl command = (TestCommandImpl) testCommandList.get(i);
 			TCExeReply reply = null;
 			try {
 				reply = command.execute();
 			} catch (Exception e) {
 				e.printStackTrace();
 				reply = new TCExeReplyImpl(e.getMessage(), false);
 			}
 			if (reply != null) {
 				result.add(reply);
 				if (!reply.passing()) {
 					log("\nThe following command is not passing: \n" +  command.getElement() + "\n");
 				}
 			}
 		}

 		String line = testFile.getName() + " is ";
 		String dirStr = "testRootSource: " + testRootSource
 						+ ", testRootWorking: " + testRootWorking;
 		if (result.passing()) {
 			line += "passing. " + dirStr;
 		} else {
 			line += "failing! " + dirStr;
 		}
 		result.setSummaryReply(line);
 		return result;
 	}

 	public void trace(String line) {
 		if (testRootOut != null) {
 			testRootOut.println(line);
 		}

 		if (currTestOut != null) {
 			currTestOut.println(line);
 		}
 	}

 	private void addCommand(Node node) {
 		if ( !(node instanceof Element)) {
 			return;
 		}
 		Element element = (Element) node;
 		if (! element.getAttribute(TestCommand.AT_Disable).equals("true")) {
 			TestCommand command = newTestCommand(element.getTagName());
 			if (command != null) {
 				command.parse(element);
 				testCommandList.add(command);
 			}
 		}
 	}

 	private TestCommand newTestCommand(String comandName) {
 		Object obj = tcClassMap.get(comandName);
 		return obj == null ? null : newTestCommand(obj.getClass());
 	}

 	public TestCommand newTestCommand(Class cls) {
 		TestCommand ret = null;
 		try {
 			ret = (TestCommand) cls.newInstance();
 			((TestCommandImpl) ret).setOwner(this);
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		return ret;
 	}

 	private MethodLibrary loadBaseLib(String name, boolean ifNewThenBuildDeafaultLib) {
 		if (currentBaseLib != null) {
 			File file = new File(currentBaseLib.eResource().getURI().toFileString()).getParentFile();
 			if (file.getName().equals(name)) {
 				return currentBaseLib;
 			}
 		}

 		if (allExports.containsKey(name)) {
 			throw new UnsupportedOperationException();
 		}

 		service.closeLibrary(currentBaseLib);

 		currentBaseLib = null;
 		String libPath = (String) allLibs.get(name);
 		if (libPath == null) {
 			libPath = currTestDir.getAbsolutePath() + File.separator + name;
 			try {
 				currentBaseLib = copyFromTestLibs(libPath, name) ?
 								XMILibraryUtil.openMethodLibrary(libPath) : null;
 			} catch (Exception e) {
 			}
 			if (currentBaseLib == null) {
 				currentBaseLib = service.createLibrary(libPath, name);
 				if (ifNewThenBuildDeafaultLib) {
 					buildDefaultLibrary();
 				}
 				trace("Base lib \"" + name + "\" is created.");
 			} else {
 				trace("Base lib \"" + name + "\" is copied from testLibs and laoded.");
 			}
 			allLibs.put(name, libPath);
 		} else {
 			try {
 				currentBaseLib = XMILibraryUtil.openMethodLibrary(libPath);
 				trace("Base lib \"" + name + "\" is loaded.");
 			} catch (Exception e) {
 			}
 		}
 		return currentBaseLib;
 	}

 	public MethodLibrary loadNonBaseLib(String name) {
 		String libPath = (String) allLibs.get(name);
 		if (libPath == null) {
 			throw new UnsupportedOperationException();
 		}
 		return service.loadLibrary(libPath);
 	}

 	public MethodLibrary getCurrentBaseLib() {
 		return currentBaseLib;
 	}

 	public void setCurrentBaseLib(MethodLibrary lib) {
 		currentBaseLib = lib;
 	}

 	public MethodLibrary loadBaseLib(String name) {
 		return loadBaseLib(name, false);
 	}

 	public MethodLibrary loadBaseLibOrBuildBaseWithDefault(String name) {
 		return loadBaseLib(name, true);
 	}

 	public File getImportFile(String importFolderName) {
 		File file = (File) allExports.get(importFolderName);
 		if (file == null) {
 			file = new File(testRootSource.getAbsolutePath() + File.separator + importFolderName);
 			if (file.exists() && file.isDirectory()) {
 				return file;
 			}
 			return null;
 		}
 		return file;
 	}

 	public File registerExportDestination(String name, boolean isXML) {
 		if (allLibs.containsKey(name)) {
 			throw new UnsupportedOperationException();
 		}
 		File file = (File) allExports.get(name);
 		if (file == null) {
 			String path = currTestDir.getAbsolutePath() + File.separator + name;
 			if (isXML) {
 				path += File.separator + name + ".xml";
 			}
 			file =  new File(path);
 			allExports.put(name, file);
 		}
 		return file;
 	}

 	public void closeLibrary(MethodLibrary lib) {
 		service.closeLibrary(lib);
 		setCurrentBaseLib(null);
 	}

 	public void closeFolder(File folder) {
 		if (removeFiles) {
 			service.deleteFolder(folder);
 		}
 	}

 	public int incExecutedTestCount() {
 		return ++executedTestCount;
 	}

 	public void closeAllExportProjects() {
 		for (Iterator it = allExports.values().iterator(); it.hasNext();) {
 			File file = (File) it.next();
 			try {
 				MethodLibraryProject.closeProject(file.getAbsolutePath(), new NullProgressMonitor());
 			} catch (Throwable e){
 			}
 		}
 	}

 	public boolean compareLibs(MethodLibrary lib1,  MethodLibrary lib2) {
 		return compareLibs(lib1, lib2, false);
 	}

 	public boolean compareLibs(MethodLibrary lib1,  MethodLibrary lib2, boolean useNameAs2ndId) {
 		LibraryDiffAnalyzor analyzor = new LibraryDiffAnalyzor(this, lib1, lib2);
 		analyzor.setGreedy(trace);
 		analyzor.setUseNameAs2ndId(useNameAs2ndId);
 		return analyzor.compare();
 	}

 	public boolean compareLibs(MethodLibrary lib1,  MethodLibrary lib2, int diffCount, int elemComparedCount, boolean useNameAs2ndId) {
 		if (diffCount == 0 && elemComparedCount == 0) {
 			return compareLibs(lib1, lib2, useNameAs2ndId);
 		}
 		LibraryDiffAnalyzor analyzor = new LibraryDiffAnalyzor(this, lib1, lib2);
 		analyzor.setGreedy(true);
 		analyzor.setUseNameAs2ndId(useNameAs2ndId);
 		analyzor.compare();
 		return 	analyzor.getDiffCount() == diffCount &&
 			 	analyzor.getElemComparedCount() == elemComparedCount;
 	}

 	public void buildDefaultLibrary() {
 		trace("buildDefaultLibrary ->");

 		MethodPlugin plugin = LibraryTestHelper.createMethodPlugin("Plug_A");
 		ContentPackage pkg = LibraryTestHelper.createContentPackage(plugin, "p1");
 		MethodConfiguration config = LibraryTestHelper.createConfiguration("Config_A");
 		CapabilityPattern cp1 = LibraryTestHelper.createCapabilityPattern(plugin, "CP1", config);
 		CapabilityPattern cp2 = LibraryTestHelper.createCapabilityPattern(plugin, "CP2", config);
 		LibraryTestHelper.setContributes(cp2, cp1);

 		// update the configuration
 		config.getMethodPluginSelection().add(plugin);
 		config.getMethodPackageSelection().add(pkg);
 		config.getMethodPackageSelection().add((ProcessComponent)cp1.eContainer());
 		config.getMethodPackageSelection().add((ProcessComponent)cp2.eContainer());

 		LibraryUtil.validateMethodConfiguration(config);

 		final String cp1_text = "cp1 main desc";
 		final String cp2_text = "cp2 main desc";

 		cp1.getPresentation().setMainDescription(cp1_text);
 		cp2.getPresentation().setMainDescription(cp2_text);

 		trace("buildDefaultLibrary <-");

 	}

 	public boolean copyFromTestLibs(String libPath, String relLibNamePath) {
 		File source = new File(testRootSource.getAbsolutePath() + File.separator + relLibNamePath);
 		String libName = source.getName();
 		File libList[] = source.getParentFile().listFiles();
 		for (int i=0; i<libList.length; i++) {
 			File file = libList[i];
 			if (libName.equals(file.getName())) {
 				File target = new File(libPath);
 				PluginImportingService.copyDir(source, target);
 				allLibs.put(libName, libPath);
 				return true;
 			}
 		}
 		return false;
 	}

 	public Document getOutputDocument() {
 		if (outputDocument == null) {
 			try {
 				outputDocument = XMLUtil.createDocument();
 		        Element root = outputDocument.createElement("TesterOutput");
 		        outputDocument.appendChild(root);
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 		return outputDocument;
 	}

 	private void clearOutputDocument() {
 		outputDocument = null;
 	}

 	public String getOutputPath() {
 		return outputPath;
 	}

 	public void log(String line) {
 		logPS.println(line);
 	}

 }
	//------------------------------------------------------------------------------
	// Copyright (c) 2005, 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 implementation
	//------------------------------------------------------------------------------
	package org.eclipse.epf.library.tester.impl;

	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.PrintStream;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.LinkedHashMap;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.epf.common.utils.XMLUtil;
	import org.eclipse.epf.importing.services.PluginImportingService;
	import org.eclipse.epf.library.project.MethodLibraryProject;
	import org.eclipse.epf.library.tester.LibraryDiffAnalyzor;
	import org.eclipse.epf.library.tester.LibraryTestService;
	import org.eclipse.epf.library.tester.iface.LibraryJunitTest;
	import org.eclipse.epf.library.tester.iface.TCExeReply;
	import org.eclipse.epf.library.tester.iface.TCExeReplyList;
	import org.eclipse.epf.library.tester.iface.TestCommand;
	import org.eclipse.epf.library.tester.iface.TestTracer;
	import org.eclipse.epf.library.tester.impl.testcommands.TCCircularDependencyCheck;
	import org.eclipse.epf.library.tester.impl.testcommands.TCCompareToGoldenFile;
	import org.eclipse.epf.library.tester.impl.testcommands.TCCompareToLibrary;
	import org.eclipse.epf.library.tester.impl.testcommands.TCCopyLibrary;
	import org.eclipse.epf.library.tester.impl.testcommands.TCEditMethodElement;
	import org.eclipse.epf.library.tester.impl.testcommands.TCExeReplyImpl;
	import org.eclipse.epf.library.tester.impl.testcommands.TCExeReplyListImpl;
	import org.eclipse.epf.library.tester.impl.testcommands.TCExportConfiguration;
	import org.eclipse.epf.library.tester.impl.testcommands.TCExportPlugins;
	import org.eclipse.epf.library.tester.impl.testcommands.TCExportXml;
	import org.eclipse.epf.library.tester.impl.testcommands.TCImportConfiguration;
	import org.eclipse.epf.library.tester.impl.testcommands.TCImportPlugins;
	import org.eclipse.epf.library.tester.impl.testcommands.TCImportXml;
	import org.eclipse.epf.library.tester.impl.testcommands.TCNewMethodConfiguration;
	import org.eclipse.epf.library.tester.impl.testcommands.TCNewMethodElement;
	import org.eclipse.epf.library.tester.impl.testcommands.TCNewMethodPlugin;
	import org.eclipse.epf.library.tester.impl.testcommands.TCOpenLibrary;
	import org.eclipse.epf.library.tester.impl.testcommands.TCOutputMethodElement;
	import org.eclipse.epf.library.tests.LibraryTestHelper;
	import org.eclipse.epf.library.util.LibraryUtil;
	import org.eclipse.epf.library.xmi.XMILibraryUtil;
	import org.eclipse.epf.uma.CapabilityPattern;
	import org.eclipse.epf.uma.ContentPackage;
	import org.eclipse.epf.uma.MethodConfiguration;
	import org.eclipse.epf.uma.MethodLibrary;
	import org.eclipse.epf.uma.MethodPlugin;
	import org.eclipse.epf.uma.ProcessComponent;
	import org.w3c.dom.Document;
	import org.w3c.dom.Element;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;

	/**
	* Used in JUnit tests
	*
	* @author Weiping Lu
	* @since 1.0
	*
	*/
	public class TestCommandMgr implements TestTracer {

	//All the tags will be formally specified and read from
	//a schema later.
	private static String TCCopyLibrary = "CopyLibrary";
	private static String TCOpenLibrary = "OpenLibrary";
	private static String TCExportPlugins = "ExportPlugins";
	private static String TCImportPlugins = "ImportPlugins";
	private static String TCExportConfiguration = "ExportConfiguration";
	private static String TCImportConfiguration = "ImportConfiguration";
	private static String TCExportXml = "ExportXml";
	private static String TCImportXml = "ImportXml";
	private static String TCCompareToLibrary = "CompareToLibrary";
	private static String TCCompareToGoldenFile = "CompareToGoldenFile";
	private static String TCNewMethodPlugin = "NewMethodPlugin";
	private static String TCNewMethodConfiguration = "NewMethodConfiguration";
	private static String TCNewMethodElement = "NewMethodElement";
	private static String TCEditMethodElement = "EditMethodElement";
	private static String TCCircularDependencyCheck = "CircularDependencyCheck";
	private static String TCEnd = "End";

	private static String TCEditPlugin="EditPlugin";
	private static String TCEditConfiguration="EditConfiguration";
	private static String TCEditContentPackage="EditContentPackage";

	public static String TCOutputLibrary="OutputLibrary";
	public static String TCOutputPlugin="OutputPlugin";
	public static String TCOutputConfiguration="OutputConfiguration";
	public static String TCOutputMethodElement="OutputMethodElement";

	private boolean trace = false;
	private boolean removeFiles = true;

	private File testRootSource;
	private File testRootWorking;
	private File currTestDir;
	private String outputPath;
	private Document outputDocument;
	private PrintStream testRootOut;
	private PrintStream currTestOut;
	private int executedTestCount = 0;

	private static LibraryTestService service = LibraryTestService.getInstance();
	private File testFile;
	private List testCommandList = new ArrayList();
	private LibraryJunitTest junitTestCase;

	private MethodLibrary currentBaseLib;
	private Map allLibs = new LinkedHashMap();
	private Map allExports = new LinkedHashMap();

	private static Map tcClassMap = new HashMap();
	private static Map tcTagNameMap = new HashMap();

	private PrintStream logPS = System.out;

	static {
	addToTcClassMap(TCCopyLibrary, TCCopyLibrary.class);
	addToTcClassMap(TCOpenLibrary, TCOpenLibrary.class);
	addToTcClassMap(TCExportPlugins, TCExportPlugins.class);
	addToTcClassMap(TCImportPlugins, TCImportPlugins.class);
	addToTcClassMap(TCExportConfiguration, TCExportConfiguration.class);
	addToTcClassMap(TCImportConfiguration, TCImportConfiguration.class);
	addToTcClassMap(TCExportXml, TCExportXml.class);
	addToTcClassMap(TCImportXml, TCImportXml.class);
	addToTcClassMap(TCCompareToLibrary, TCCompareToLibrary.class);
	addToTcClassMap(TCCompareToGoldenFile, TCCompareToGoldenFile.class);

	addToTcClassMap(TCNewMethodPlugin, TCNewMethodPlugin.class);
	addToTcClassMap(TCNewMethodConfiguration, TCNewMethodConfiguration.class);
	addToTcClassMap(TCNewMethodElement, TCNewMethodElement.class);
	addToTcClassMap(TCEditMethodElement, TCEditMethodElement.class);

	addToTcClassMap(TCEditPlugin, TCEditMethodElement.class);
	addToTcClassMap(TCEditConfiguration, TCEditMethodElement.class);
	addToTcClassMap(TCEditContentPackage, TCEditMethodElement.class);

	addToTcClassMap(TCOutputLibrary, TCOutputMethodElement.class);
	addToTcClassMap(TCOutputPlugin, TCOutputMethodElement.class);
	addToTcClassMap(TCOutputConfiguration, TCOutputMethodElement.class);
	addToTcClassMap(TCOutputMethodElement, TCOutputMethodElement.class);
	addToTcClassMap(TCCircularDependencyCheck, TCCircularDependencyCheck.class);
	}

	private static void addToTcClassMap(String elementName, Class cls) {
	Object instance = null;
	try {
	instance = cls.newInstance();
	} catch (Exception e){
	e.printStackTrace();
	}
	if (instance instanceof TestCommand) {
	tcClassMap.put(elementName, instance);
	tcTagNameMap.put(cls, elementName);
	}
	}

	public TestCommandMgr(boolean trace) {
	if (trace) {
	this.trace = trace;
	this.removeFiles = !trace;
	}
	}

	public String getTagName(TestCommand tcInstance) {
	return (String) tcTagNameMap.get(tcInstance.getClass());
	}

	public void setTestRootSource(File dirFile) {
	testRootSource = dirFile;
	}

	public void setTestRootWorking(File dirFile) {
	boolean needToCreateOutputFile = testRootWorking == null \|\|
	! testRootWorking.equals(dirFile);

	testRootWorking = dirFile;

	if (trace && needToCreateOutputFile) {
	try {
	if (! testRootWorking.exists()) {
	if (! mkDir(testRootWorking)) {
	return;
	}
	}
	if (testRootOut != null) {
	testRootOut.close();
	}
	String path = testRootWorking.getAbsolutePath() + File.separator + "traces.out";
	testRootOut = new PrintStream(new FileOutputStream(path));

	} catch (Exception e) {
	e.printStackTrace();
	}
	}
	}

	private boolean mkDir(File file) {
	File pFile = file.getParentFile();
	if (! pFile.exists()) {
	if (! mkDir(pFile)) {
	return false;
	}
	}
	return file.mkdir();
	}

	public void openCurrTestDir(File dirFile) {
	currTestDir = dirFile;

	try {
	if (! currTestDir.exists()) {
	currTestDir.mkdir();
	}
	String path = currTestDir.getAbsolutePath() + File.separator;
	if (trace) {
	currTestOut = new PrintStream(new FileOutputStream(path + "trace.out"));
	}
	outputPath = path + "output.xml";
	} catch (Exception e) {
	e.printStackTrace();
	}
	}

	public void closeCurrTestDir() {
	closeLibrary(getCurrentBaseLib());
	if (currTestOut != null) {
	currTestOut.close();
	currTestOut = null;
	}
	clearOutputDocument();
	allLibs = new LinkedHashMap();
	allExports = new LinkedHashMap();
	closeFolder(currTestDir);
	}

	public void doneWithAllTests(File topCleanUpFolder) {
	closeAllExportProjects();
	if (testRootOut != null) {
	testRootOut.close();
	}
	closeFolder(topCleanUpFolder);
	}

	public File getCurrTestDir() {
	return currTestDir;
	}

	public void setTest(File testFile) {
	this.testFile = testFile;
	}

	public File getTestFile() {
	return testFile;
	}


	public LibraryTestService getService() {
	return service;
	}

	public TCExeReplyList execute() {
	trace("Begin executing: " + testFile);

	TCExeReplyList result = null;
	boolean loaded = false;
	Exception loadException = null;
	try {
	loaded = loadTest();
	} catch (Exception e) {
	loadException = e;
	e.printStackTrace();
	}

	if (loaded) {
	String path = testRootWorking.getAbsolutePath() + File.separator + testFile.getName() + ".dir";
	openCurrTestDir(new File (path));
	result = executeCommands();
	closeCurrTestDir();
	} else {
	result = new TCExeReplyListImpl();
	if (loadException != null) {
	String msg = "Test load failed: " + loadException.getMessage();
	((TCExeReplyListImpl) result).add(new TCExeReplyImpl(msg, false));
	trace(msg);
	} else {
	trace("Test disabled");
	}
	}

	trace("End executing : " + testFile);
	return result;
	}

	private boolean loadTest() throws Exception {
	testCommandList.clear();
	Document document = XMLUtil.loadXml(testFile);
	Element root = document.getDocumentElement();
	if (root.getAttribute(TestCommand.AT_Disable).equals("true")) {
	return false;
	}
	boolean verbose = root.getAttribute(TestCommand.AT_Verbose).equalsIgnoreCase("true");
	NodeList nodes = root.getChildNodes();
	int sz = nodes == null ? 0 : nodes.getLength();
	for (int i=0; i<sz; i++) {
	Node node = nodes.item(i);
	if (node instanceof Element) {
	Element element = (Element) node;
	if (verbose) {
	element.setAttribute(TestCommand.AT_Verbose, "true");
	}
	if (element.getTagName().equalsIgnoreCase(TCEnd)) {
	break;
	}
	addCommand(node);
	}
	}
	return true;
	}

	public TCExeReplyList executeCommands() {
	TCExeReplyListImpl result = new TCExeReplyListImpl();
	for (int i=0; i<testCommandList.size(); i++) {
	TestCommandImpl command = (TestCommandImpl) testCommandList.get(i);
	TCExeReply reply = null;
	try {
	reply = command.execute();
	} catch (Exception e) {
	e.printStackTrace();
	reply = new TCExeReplyImpl(e.getMessage(), false);
	}
	if (reply != null) {
	result.add(reply);
	if (!reply.passing()) {
	log("\nThe following command is not passing: \n" + command.getElement() + "\n");
	}
	}
	}

	String line = testFile.getName() + " is ";
	String dirStr = "testRootSource: " + testRootSource
	+ ", testRootWorking: " + testRootWorking;
	if (result.passing()) {
	line += "passing. " + dirStr;
	} else {
	line += "failing! " + dirStr;
	}
	result.setSummaryReply(line);
	return result;
	}

	public void trace(String line) {
	if (testRootOut != null) {
	testRootOut.println(line);
	}

	if (currTestOut != null) {
	currTestOut.println(line);
	}
	}

	private void addCommand(Node node) {
	if ( !(node instanceof Element)) {
	return;
	}
	Element element = (Element) node;
	if (! element.getAttribute(TestCommand.AT_Disable).equals("true")) {
	TestCommand command = newTestCommand(element.getTagName());
	if (command != null) {
	command.parse(element);
	testCommandList.add(command);
	}
	}
	}

	private TestCommand newTestCommand(String comandName) {
	Object obj = tcClassMap.get(comandName);
	return obj == null ? null : newTestCommand(obj.getClass());
	}

	public TestCommand newTestCommand(Class cls) {
	TestCommand ret = null;
	try {
	ret = (TestCommand) cls.newInstance();
	((TestCommandImpl) ret).setOwner(this);
	} catch (Exception e) {
	e.printStackTrace();
	}
	return ret;
	}

	private MethodLibrary loadBaseLib(String name, boolean ifNewThenBuildDeafaultLib) {
	if (currentBaseLib != null) {
	File file = new File(currentBaseLib.eResource().getURI().toFileString()).getParentFile();
	if (file.getName().equals(name)) {
	return currentBaseLib;
	}
	}

	if (allExports.containsKey(name)) {
	throw new UnsupportedOperationException();
	}

	service.closeLibrary(currentBaseLib);

	currentBaseLib = null;
	String libPath = (String) allLibs.get(name);
	if (libPath == null) {
	libPath = currTestDir.getAbsolutePath() + File.separator + name;
	try {
	currentBaseLib = copyFromTestLibs(libPath, name) ?
	XMILibraryUtil.openMethodLibrary(libPath) : null;
	} catch (Exception e) {
	}
	if (currentBaseLib == null) {
	currentBaseLib = service.createLibrary(libPath, name);
	if (ifNewThenBuildDeafaultLib) {
	buildDefaultLibrary();
	}
	trace("Base lib \"" + name + "\" is created.");
	} else {
	trace("Base lib \"" + name + "\" is copied from testLibs and laoded.");
	}
	allLibs.put(name, libPath);
	} else {
	try {
	currentBaseLib = XMILibraryUtil.openMethodLibrary(libPath);
	trace("Base lib \"" + name + "\" is loaded.");
	} catch (Exception e) {
	}
	}
	return currentBaseLib;
	}

	public MethodLibrary loadNonBaseLib(String name) {
	String libPath = (String) allLibs.get(name);
	if (libPath == null) {
	throw new UnsupportedOperationException();
	}
	return service.loadLibrary(libPath);
	}

	public MethodLibrary getCurrentBaseLib() {
	return currentBaseLib;
	}

	public void setCurrentBaseLib(MethodLibrary lib) {
	currentBaseLib = lib;
	}

	public MethodLibrary loadBaseLib(String name) {
	return loadBaseLib(name, false);
	}

	public MethodLibrary loadBaseLibOrBuildBaseWithDefault(String name) {
	return loadBaseLib(name, true);
	}

	public File getImportFile(String importFolderName) {
	File file = (File) allExports.get(importFolderName);
	if (file == null) {
	file = new File(testRootSource.getAbsolutePath() + File.separator + importFolderName);
	if (file.exists() && file.isDirectory()) {
	return file;
	}
	return null;
	}
	return file;
	}

	public File registerExportDestination(String name, boolean isXML) {
	if (allLibs.containsKey(name)) {
	throw new UnsupportedOperationException();
	}
	File file = (File) allExports.get(name);
	if (file == null) {
	String path = currTestDir.getAbsolutePath() + File.separator + name;
	if (isXML) {
	path += File.separator + name + ".xml";
	}
	file = new File(path);
	allExports.put(name, file);
	}
	return file;
	}

	public void closeLibrary(MethodLibrary lib) {
	service.closeLibrary(lib);
	setCurrentBaseLib(null);
	}

	public void closeFolder(File folder) {
	if (removeFiles) {
	service.deleteFolder(folder);
	}
	}

	public int incExecutedTestCount() {
	return ++executedTestCount;
	}

	public void closeAllExportProjects() {
	for (Iterator it = allExports.values().iterator(); it.hasNext();) {
	File file = (File) it.next();
	try {
	MethodLibraryProject.closeProject(file.getAbsolutePath(), new NullProgressMonitor());
	} catch (Throwable e){
	}
	}
	}

	public boolean compareLibs(MethodLibrary lib1, MethodLibrary lib2) {
	return compareLibs(lib1, lib2, false);
	}

	public boolean compareLibs(MethodLibrary lib1, MethodLibrary lib2, boolean useNameAs2ndId) {
	LibraryDiffAnalyzor analyzor = new LibraryDiffAnalyzor(this, lib1, lib2);
	analyzor.setGreedy(trace);
	analyzor.setUseNameAs2ndId(useNameAs2ndId);
	return analyzor.compare();
	}

	public boolean compareLibs(MethodLibrary lib1, MethodLibrary lib2, int diffCount, int elemComparedCount, boolean useNameAs2ndId) {
	if (diffCount == 0 && elemComparedCount == 0) {
	return compareLibs(lib1, lib2, useNameAs2ndId);
	}
	LibraryDiffAnalyzor analyzor = new LibraryDiffAnalyzor(this, lib1, lib2);
	analyzor.setGreedy(true);
	analyzor.setUseNameAs2ndId(useNameAs2ndId);
	analyzor.compare();
	return analyzor.getDiffCount() == diffCount &&
	analyzor.getElemComparedCount() == elemComparedCount;
	}

	public void buildDefaultLibrary() {
	trace("buildDefaultLibrary ->");

	MethodPlugin plugin = LibraryTestHelper.createMethodPlugin("Plug_A");
	ContentPackage pkg = LibraryTestHelper.createContentPackage(plugin, "p1");
	MethodConfiguration config = LibraryTestHelper.createConfiguration("Config_A");
	CapabilityPattern cp1 = LibraryTestHelper.createCapabilityPattern(plugin, "CP1", config);
	CapabilityPattern cp2 = LibraryTestHelper.createCapabilityPattern(plugin, "CP2", config);
	LibraryTestHelper.setContributes(cp2, cp1);

	// update the configuration
	config.getMethodPluginSelection().add(plugin);
	config.getMethodPackageSelection().add(pkg);
	config.getMethodPackageSelection().add((ProcessComponent)cp1.eContainer());
	config.getMethodPackageSelection().add((ProcessComponent)cp2.eContainer());

	LibraryUtil.validateMethodConfiguration(config);

	final String cp1_text = "cp1 main desc";
	final String cp2_text = "cp2 main desc";

	cp1.getPresentation().setMainDescription(cp1_text);
	cp2.getPresentation().setMainDescription(cp2_text);

	trace("buildDefaultLibrary <-");

	}

	public boolean copyFromTestLibs(String libPath, String relLibNamePath) {
	File source = new File(testRootSource.getAbsolutePath() + File.separator + relLibNamePath);
	String libName = source.getName();
	File libList[] = source.getParentFile().listFiles();
	for (int i=0; i<libList.length; i++) {
	File file = libList[i];
	if (libName.equals(file.getName())) {
	File target = new File(libPath);
	PluginImportingService.copyDir(source, target);
	allLibs.put(libName, libPath);
	return true;
	}
	}
	return false;
	}

	public Document getOutputDocument() {
	if (outputDocument == null) {
	try {
	outputDocument = XMLUtil.createDocument();
	Element root = outputDocument.createElement("TesterOutput");
	outputDocument.appendChild(root);
	} catch (Exception e) {
	e.printStackTrace();
	}
	}
	return outputDocument;
	}

	private void clearOutputDocument() {
	outputDocument = null;
	}

	public String getOutputPath() {
	return outputPath;
	}

	public void log(String line) {
	logPS.println(line);
	}

	}