abstractcoretestcase.java

eclipseme的最新版本的source,欢迎j2me程序员使用

/**
 * Copyright (c) 2003-2005 Craig Setera
 * All Rights Reserved.
 * Licensed under the Eclipse Public License - v 1.0
 * For more information see http://www.eclipse.org/legal/epl-v10.html
 */
package eclipseme.core.model;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import junit.framework.TestCase;

import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;

import eclipseme.core.model.MidletSuiteFactory.MidletSuiteCreationRunnable;
import eclipseme.core.model.device.DeviceFactory;
import eclipseme.core.model.device.IDevice;
import eclipseme.core.model.device.SimpleFoundDevicesList;

/**
 * Type description
 * <p />
 * Copyright (c) 2003-2005 Craig Setera<br>
 * All Rights Reserved.<br>
 * Licensed under the Eclipse Public License - v 1.0<p/>
 * <br>
 * $Revision: 1.1 $
 * <br>
 * $Date: 2006/02/11 21:26:56 $
 * <br>
 * @author Craig Setera
 */
public abstract class AbstractCoreTestCase extends TestCase {
	private class TempMidletSuiteCreationRunnable implements IWorkspaceRunnable {
		private IDevice device;
		private IMidletSuiteProject midletSuite;
		
		public TempMidletSuiteCreationRunnable(IDevice device) {
			this.device = device;
		}

		public void run(IProgressMonitor monitor) throws CoreException {
			IProject project = createTemporaryProject(monitor);
			IJavaProject javaProject = createJavaProject(project, monitor);
			midletSuite = createMidletSuite(project, javaProject, monitor);
		}

		public IMidletSuiteProject getMidletSuite() {
			return midletSuite;
		}
		
		/**
		 * Add the Java nature to the project.
		 * @throws CoreException 
		 *
		 */
		private void addJavaNature(IProject project, IProgressMonitor monitor) 
			throws CoreException 
		{
			if (!project.hasNature(JavaCore.NATURE_ID)) {
				IProjectDescription description = project.getDescription();
				String[] prevNatures= description.getNatureIds();
				String[] newNatures= new String[prevNatures.length + 1];
				System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
				newNatures[prevNatures.length]= JavaCore.NATURE_ID;
				description.setNatureIds(newNatures);
				project.setDescription(description, monitor);
			}
		}

		/**
		 * Create the Java project wrapper around the specified project.
		 * 
		 * @param project
		 * @param monitor
		 * @return
		 * @throws CoreException 
		 */
		private IJavaProject createJavaProject(IProject project, IProgressMonitor monitor) 
			throws CoreException 
		{
			// Create the source and output folders
			IFolder srcFolder = project.getFolder("src");
			srcFolder.create(true, true, monitor);
			IFolder binFolder = project.getFolder("bin");
			binFolder.create(true, true, monitor);

			// Set up a valid java project
			IClasspathEntry entry = JavaCore.newSourceEntry(srcFolder.getFullPath());
			addJavaNature(project, monitor);
			IJavaProject javaProject = JavaCore.create(project);
			javaProject.setRawClasspath(
				new IClasspathEntry[] { entry },
				binFolder.getFullPath(),
				monitor);

			return javaProject;
		}

		/**
		 * Create the midlet suite support.
		 * 
		 * @param project
		 * @param javaProject
		 * @param monitor
		 * @return
		 * @throws CoreException
		 */
		private IMidletSuiteProject createMidletSuite(
			IProject project, 
			IJavaProject javaProject, 
			IProgressMonitor monitor) 
				throws CoreException 
		{
			String jadName = project.getName() + ".jad";
			MidletSuiteCreationRunnable runnable =
				MidletSuiteFactory.getMidletSuiteCreationRunnable(
						project, 
						javaProject, 
						device, 
						jadName);
			
			try {
				runnable.run(monitor);
			} catch (InvocationTargetException e) {
				throw (CoreException) e.getCause();
			} catch (InterruptedException e) {
			}
			
			return MidletSuiteFactory.getMidletSuiteProject(javaProject);
		}

		/**
		 * Create a plain temporary project.
		 * 
		 * @return
		 * @throws CoreException 
		 */
		protected IProject createTemporaryProject(IProgressMonitor monitor) 
			throws CoreException 
		{
			String projectName = "P" + System.currentTimeMillis();
			
			IWorkspace workspace = ResourcesPlugin.getWorkspace();
			IProject project = workspace.getRoot().getProject(projectName);
	        IProjectDescription description = workspace.newProjectDescription(projectName);
	        
	        project.create(description, monitor);
	        project.open(IResource.BACKGROUND_REFRESH, monitor);

			return project;
		}
	};
	
	/** 
	 * Regular expression for matching replaceable values within
	 * a device XML property file.
	 */ 
	private static Pattern PROPS_PATTERN = Pattern.compile("\\$\\{(.*?)\\}");

	/**
	 * Fail with the specified exception.
	 * @param e
	 */
	protected void fail(Exception e) {
		e.printStackTrace();
		fail(e.toString());
	}

	/**
	 * Return a file instance for the specified key.
	 * 
	 * @param key
	 * @return
	 */
	protected File getFileForProperty(String key) {
		File propertyFile = null;
		
		String value = getResolvedPropertyValue(key);
		if (value != null) {
			propertyFile = new File(value);
		}
		
		return propertyFile;
	}
	
	/**
	 * Get the property value correctly resolved.
	 * 
	 * @param propValue
	 * @return
	 */
	protected String getResolvedPropertyValue(String key) {
		Properties props = System.getProperties();
		
		String value = props.getProperty(key); 
		if (value == null) value = "";

		int offset = 0;
		StringBuffer sb = new StringBuffer(value);
		Matcher matcher = PROPS_PATTERN.matcher(sb);
		
		while (matcher.find(offset)) {
			String referencedProp = matcher.group(1);
			String resolvedReferenced = 
				getResolvedPropertyValue(referencedProp);
			sb.replace(matcher.start(), matcher.end(), resolvedReferenced);
			
			// Figure out the new offset, based on the replaced
			// string length
			offset = matcher.start() + resolvedReferenced.length();
			
			value = sb.toString();
			props.setProperty(key, value);
		}
		
		return value;
	}

	/**
	 * @see junit.framework.TestCase#setUp()
	 */
	protected void setUp() throws Exception {
		super.setUp();
		loadProperties();
	}

	/**
	 * Load the test properties into the system properties. 
	 */
	protected void loadProperties() {
		InputStream is = AbstractCoreTestCase.class.getClassLoader().getResourceAsStream("test.properties");
		loadProperties(is);
	}

	/**
	 * Load the test properties into the system properties. 
	 */
	protected void loadProperties(InputStream is) {
		if (is == null) {
			fail("Failed to find properties to load");
		} else {
			try {
				System.getProperties().load(is);
			} catch (IOException e) {
				fail(e);
			} finally {
				try { is.close(); } catch (IOException e) {}
			}
		}
	}
	
	/**
	 * Create a temporary midlet suite that can be used for testing
	 * purposes.
	 * 
	 * @return
	 * @throws CoreException 
	 */
	protected IMidletSuiteProject createTemporaryMidletSuite(IDevice device) 
		throws CoreException 
	{
		TempMidletSuiteCreationRunnable runnable = 
			new TempMidletSuiteCreationRunnable(device);
		runnable.run(new NullProgressMonitor());
		return runnable.getMidletSuite();
	}
	
	/**
	 * Remove a temporary midlet suite created for testing purposes.
	 * 
	 * @param createdSuite2
	 * @throws CoreException 
	 */
	protected void removeTemporaryMidletSuite(IMidletSuiteProject createdSuite) 
		throws CoreException 
	{
		IProject project = createdSuite.getProject();
		if (project != null && project.exists()) {
			project.delete(true, false, new NullProgressMonitor());
		}
	}

	protected IDevice getTestDevice() throws Exception {
		return getTestDevices()[0];
	}
	
	protected IDevice[] getTestDevices() throws Exception {
		File wtkRoot = getFileForProperty("wtk.root");
		assertNotNull("WTK root is null", wtkRoot);
		assertTrue("WTK root does not exist", wtkRoot.exists());

		SimpleFoundDevicesList list = new SimpleFoundDevicesList();
		DeviceFactory.findDevices(wtkRoot, list, new NullProgressMonitor());
		IDevice[] devices = list.getDevices();
		assertNotNull("Devices are null", devices);
		assertEquals("Expected 4 devices", 4, devices.length);
		
		return devices;
	}
}