| //------------------------------------------------------------------------------ |
| // 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.edit.util.LibraryEditUtil; |
| 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; |
| } |
| |
| LibraryEditUtil.getInstance().setJunitTest(true); |
| } |
| |
| 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) { |
| trace(e.getMessage()); |
| } |
| } |
| 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); |
| } |
| |
| } |