Attachment #21392 for bug #82195

Lines 3-5 Link Here

(-)build.properties (+7 lines)
3	bin.includes = plugin.xml,\	3	bin.includes = plugin.xml,\
4	tests.jar,\	4	tests.jar,\
5	resources/	5	resources/
		6	src.includes = .classpath,\
		7	.project,\
		8	ChangeLog,\
		9	build.properties,\
		10	plugin.xml,\
		11	resources/,\
		12	src/

Lines 16-22 Link Here

(-)plugin.xml (-1 lines)
16	<requires>	16	<requires>
17	<import plugin="org.eclipse.ui"/>	17	<import plugin="org.eclipse.ui"/>
18	<import plugin="org.eclipse.core.runtime"/>	18	<import plugin="org.eclipse.core.runtime"/>
19	<import plugin="org.eclipse.cdt.core"/>
20	<import plugin="org.eclipse.cdt.rpm.core"/>	19	<import plugin="org.eclipse.cdt.rpm.core"/>
21	<import plugin="org.eclipse.core.resources"/>	20	<import plugin="org.eclipse.core.resources"/>
22	<import plugin="org.junit"/>	21	<import plugin="org.junit"/>

Lines 1-5 Link Here

(-)src/org/eclipse/cdt/rpm/core/tests/AllTests.java (-1 / +4 lines)
1	/*	1	/*
2	* (c) 2004 Red Hat, Inc.	2	* (c) 2004, 2005 Red Hat, Inc.
3	*	3	*
4	* This program is open source software licensed under the	4	* This program is open source software licensed under the
5	* Eclipse Public License ver. 1	5	* Eclipse Public License ver. 1
Lines 7-12 Link Here
7	package org.eclipse.cdt.rpm.core.tests;	7	package org.eclipse.cdt.rpm.core.tests;
8		8
9		9
		10	import org.eclipse.cdt.rpm.core.internal.tests.RPMCoreInternalTestSuite;
		11
10	import junit.framework.Test;	12	import junit.framework.Test;
11	import junit.framework.TestSuite;	13	import junit.framework.TestSuite;
12		14
Lines 15-20 Link Here
15	public static Test suite() {	17	public static Test suite() {
16	TestSuite suite = new TestSuite("Test for org.eclipse.cdt.rpm.core.tests");	18	TestSuite suite = new TestSuite("Test for org.eclipse.cdt.rpm.core.tests");
17	//$JUnit-BEGIN$	19	//$JUnit-BEGIN$
		20	suite.addTest(RPMCoreInternalTestSuite.suite());
18	suite.addTest(RPMCoreTestSuite.suite());	21	suite.addTest(RPMCoreTestSuite.suite());
19	//$JUnit-END$	22	//$JUnit-END$
20	return suite;	23	return suite;




package org.eclipse.cdt.rpm.core.tests;

import junit.framework.Assert;

import org.eclipse.cdt.core.CCProjectNature;
import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.CProjectNature;
import org.eclipse.cdt.core.model.CModelException;
import org.eclipse.cdt.core.model.CoreModel;
import org.eclipse.cdt.core.model.IArchive;
import org.eclipse.cdt.core.model.IArchiveContainer;
import org.eclipse.cdt.core.model.IBinary;
import org.eclipse.cdt.core.model.IBinaryContainer;
import org.eclipse.cdt.core.model.ICContainer;
import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.model.ISourceRoot;
import org.eclipse.cdt.core.model.ITranslationUnit;
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.IWorkspaceRoot;
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.IStatus;
import org.eclipse.ui.dialogs.IOverwriteQuery;

/**
 * Helper methods to set up a ICProject.
 */
public class CProjectHelper {

	/**
	 * Creates a ICProject.
	 */
	public static ICProject createCProject(final String projectName, String binFolderName) throws CoreException {
		final IWorkspace ws = ResourcesPlugin.getWorkspace();
		final IProject newProject[] = new IProject[1];
		ws.run(new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				IWorkspaceRoot root = ws.getRoot();
				IProject project = root.getProject(projectName);
				if (!project.exists()) {
					project.create(null);
				} else {
					project.refreshLocal(IResource.DEPTH_INFINITE, null);
				}
				if (!project.isOpen()) {
					project.open(null);
				}
				if (!project.hasNature(CProjectNature.C_NATURE_ID)) {
					String projectId = "TestProject";
					addNatureToProject(project, CProjectNature.C_NATURE_ID, null);
					CCorePlugin.getDefault().mapCProjectOwner(project, projectId, false);
				}
				newProject[0] = project;
			}
		}, null);

		return CCorePlugin.getDefault().getCoreModel().create(newProject[0]);
	}
	
	private static String getMessage(IStatus status) {
		StringBuffer message = new StringBuffer("[");
		message.append(status.getMessage());
		if (status.isMultiStatus()) {
			IStatus children[] = status.getChildren();
			for( int i = 0; i < children.length; i++) {
				message.append(getMessage(children[i]));
			}
		}
		message.append("]");
		return message.toString();
	}

	public static ICProject createCCProject(final String projectName, final String binFolderName) throws CoreException {
		final IWorkspace ws = ResourcesPlugin.getWorkspace();
		final ICProject newProject[] = new ICProject[1];
		ws.run(new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ICProject cproject = createCProject(projectName, binFolderName);
				if (!cproject.getProject().hasNature(CCProjectNature.CC_NATURE_ID)) {
					addNatureToProject(cproject.getProject(), CCProjectNature.CC_NATURE_ID, null);
				}
				newProject[0] = cproject;
			}
		}, null);
		return newProject[0];
	}

	/**
	 * Removes a ICProject.
	 */
	public static void delete(ICProject cproject) {
		try {
			cproject.getProject().delete(true, true, null);
		} catch (CoreException e) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e1) {
			} finally {
				try {
					System.gc();
					System.runFinalization();
					cproject.getProject().delete(true, true, null);
				} catch (CoreException e2) {
					Assert.fail(getMessage(e2.getStatus()));
				}
			}
		}
	}

	/**
	 * Adds a folder container to a ICProject.
	 */
	public static ICContainer addCContainer(ICProject cproject, String containerName) throws CoreException {
		IProject project = cproject.getProject();
		ICContainer container = null;
		if (containerName == null || containerName.length() == 0) {
			ICContainer[] conts = cproject.getSourceRoots();
			if (conts.length > 0) {
				container = conts[0];
			}
		} else {
			IFolder folder = project.getFolder(containerName);
			if (!folder.exists()) {
				folder.create(false, true, null);
			}
			container = CoreModel.getDefault().create(folder);
		}
		return container;
	}


	/**
	 * Removes a folder from a ICProject.
	 */
	public static void removeCContainer(ICProject cproject, String containerName) throws CoreException {
		IFolder folder = cproject.getProject().getFolder(containerName);
		folder.delete(true, null);
	}

	/**
	 * Attempts to find an archive with the given name in the workspace
	 */
	public static IArchive findArchive(ICProject testProject, String name) throws CModelException {
		int x;
		IArchive[] myArchives;
		IArchiveContainer archCont;
		/***************************************************************************************************************************
		 * Since ArchiveContainer.getArchives does not wait until all the archives in the project have been parsed before returning
		 * the list, we have to do a sync ArchiveContainer.getChildren first to make sure we find all the archives.
		 */
		archCont = testProject.getArchiveContainer();
		myArchives = archCont.getArchives();
		if (myArchives.length < 1)
			return (null);
		for (x = 0; x < myArchives.length; x++) {
			if (myArchives[x].getElementName().equals(name))
				return (myArchives[x]);
		}
		return (null);
	}

	/**
	 * Attempts to find a binary with the given name in the workspace
	 */
	public static IBinary findBinary(ICProject testProject, String name) throws CModelException {
		IBinaryContainer binCont;
		int x;
		IBinary[] myBinaries;
		binCont = testProject.getBinaryContainer();
		myBinaries = binCont.getBinaries();
		if (myBinaries.length < 1)
			return (null);
		for (x = 0; x < myBinaries.length; x++) {
			if (myBinaries[x].getElementName().equals(name))
				return (myBinaries[x]);
		}
		return (null);
	}

	/**
	 * Attempts to find an object with the given name in the workspace
	 */
	public static IBinary findObject(ICProject testProject, String name) throws CModelException {
		ICElement[] sourceRoots = testProject.getChildren();
		for (int i = 0; i < sourceRoots.length; i++) {
			ISourceRoot root = (ISourceRoot) sourceRoots[i];
			ICElement[] myElements = root.getChildren();
			for (int x = 0; x < myElements.length; x++) {
				if (myElements[x].getElementName().equals(name)) {
					if (myElements[x] instanceof IBinary) {
						return ((IBinary) myElements[x]);
					}
				}
			}
		}
		return null;
	}

	/**
	 * Attempts to find a TranslationUnit with the given name in the workspace
	 */
	public static ITranslationUnit findTranslationUnit(ICProject testProject, String name) throws CModelException {
		ICElement[] sourceRoots = testProject.getChildren();
		for (int i = 0; i < sourceRoots.length; i++) {
			ISourceRoot root = (ISourceRoot) sourceRoots[i];
			ICElement[] myElements = root.getChildren();
			for (int x = 0; x < myElements.length; x++) {
				if (myElements[x].getElementName().equals(name)) {
					if (myElements[x] instanceof ITranslationUnit) {
						return ((ITranslationUnit) myElements[x]);
					}
				}
			}
		}
		return null;
	}

	/**
	 * Attempts to find an element with the given name in the workspace
	 */
	public static ICElement findElement(ICProject testProject, String name) throws CModelException {
		ICElement[] sourceRoots = testProject.getChildren();
		for (int i = 0; i < sourceRoots.length; i++) {
			ISourceRoot root = (ISourceRoot) sourceRoots[i];
			ICElement[] myElements = root.getChildren();
			for (int x = 0; x < myElements.length; x++) {
				if (myElements[x].getElementName().equals(name)) {
					return myElements[x];
				}
			}
		}
		return null;
	}

	private static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException {
		IProjectDescription description = proj.getDescription();
		String[] prevNatures = description.getNatureIds();
		String[] newNatures = new String[prevNatures.length + 1];
		System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
		newNatures[prevNatures.length] = natureId;
		description.setNatureIds(newNatures);
		proj.setDescription(description, monitor);
	}

	private static class ImportOverwriteQuery implements IOverwriteQuery {

		public String queryOverwrite(String file) {
			return ALL;
		}
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/cdt/rpm/core/tests/RPMCoreTestSuite.java (-4 / +3 lines)
1	/*	1	/*
2	* (c) 2004 Red Hat, Inc.	2	* (c) 2004, 2005 Red Hat, Inc.
3	*	3	*
4	* This program is open source software licensed under the	4	* This program is open source software licensed under the
5	* Eclipse Public License ver. 1	5	* Eclipse Public License ver. 1
Lines 15-23 Link Here
15	TestSuite suite = new TestSuite(	15	TestSuite suite = new TestSuite(
16	"Test for org.eclipse.cdt.rpm.core.tests");	16	"Test for org.eclipse.cdt.rpm.core.tests");
17	//$JUnit-BEGIN$	17	//$JUnit-BEGIN$
18	suite.addTest(RPMExportTests.suite());	18	suite.addTestSuite(RPMProjectNatureTest.class);
19	suite.addTest(SRPMImportTests.suite());	19	suite.addTestSuite(RPMProjectFactoryTest.class);
20	suite.addTest(SRPMExportTests.suite());
21	//$JUnit-END$	20	//$JUnit-END$
22	return suite;	21	return suite;
23	}	22	}

Lines 1-5 Link Here

(-)src/org/eclipse/cdt/rpm/core/tests/RPMCoreTestsPlugin.java (-1 / +1 lines)
1	/*	1	/*
2	* (c) 2004 Red Hat, Inc.	2	* (c) 2004, 2005 Red Hat, Inc.
3	*	3	*
4	* This program is open source software licensed under the	4	* This program is open source software licensed under the
5	* Eclipse Public License ver. 1	5	* Eclipse Public License ver. 1




/*
 * (c) 2004 Red Hat, Inc.
 *
 * This program is open source software licensed under the 
 * Eclipse Public License ver. 1
 */
package org.eclipse.cdt.rpm.core.tests;

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.net.URL;

import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.rpm.core.RPMExport;
import org.eclipse.cdt.rpm.core.SRPMImport;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;

import junit.framework.TestCase;
import junit.framework.TestSuite;


/**
 * @author Jeremy Handcock <handcock@redhat.com>
 * 
 * This class tests the RPM plug-in's core SRPM import operation
 */
public class RPMExportTests extends TestCase {
	IWorkspace workspace;
	IWorkspaceRoot root;
	NullProgressMonitor monitor;
	String pluginRoot;
	static final String file_sep = System.getProperty("file.separator"); //$NON-NLS-1$
	
	/**
	 * Constructor for RPMExportTests.
	 * @param name
	 */
	public RPMExportTests(String name) {
		super(name);
	}
	
	/*
	 * @see TestCase#setUp()
	 */
	protected void setUp() throws Exception {
		IWorkspaceDescription desc;
		workspace = ResourcesPlugin.getWorkspace();
		root = workspace.getRoot();
		monitor = new NullProgressMonitor();
		if(workspace == null) {
			fail("Workspace was not setup");
		}
		if(root == null) {
			fail("Workspace root was not setup");
		}
		desc = workspace.getDescription();
		desc.setAutoBuilding(false);
		workspace.setDescription(desc);
	}
	
	public static TestSuite suite() {
		return new TestSuite(RPMExportTests.class);
	}
	
	public void testHelloWorldRPMExport() throws CoreException, IOException {
		/* Create C project to use during the test */
		RPMExportTester("helloworld", "2", "2");
	}
	
	private void RPMExportTester(String name, String version, String release) 
		throws CoreException, IOException {
		
		/* Create C project to use during the test */
		ICProject testProject = CProjectHelper.createCProject(name, "none"); //$NON-NLS-1$ //$NON-NLS-2$
		if(testProject == null) {
			fail("Unable to create project");
		}
		
		URL url = RPMCoreTestsPlugin.getDefault().find(new Path("resources" + file_sep + "srpms" + 
				file_sep + name+"-"+version+"-"+release+".src.rpm"));
		if (url == null)
			fail("Unable to find resources" + file_sep + "srpms" + file_sep +
				name+"-"+version+"-"+release+".src.rpm");
		
		SRPMImport SRPMImport = new SRPMImport(testProject.getProject().getLocation().
				toOSString(), Platform.asLocalURL(url).getPath());
		SRPMImport.setDoAutoconf(true);
		SRPMImport.setDoPatches(true);
		SRPMImport.run();
		
		/* Export the SRPM */
		RPMExport rpmExport = new RPMExport(testProject.getProject().getLocation().toOSString());
		// set the various properties for an RPM export
		
		rpmExport.setUi_ver_no(version);
		rpmExport.setUi_rel_no(release);
		rpmExport.setUi_spec_file("");
		
		rpmExport.run();
		
		File f = new File(testProject.getProject().getLocation().toOSString());
		FilenameFilter rpms = new FilenameFilter() {
			public boolean accept(File dir, String name) {
				return (name.endsWith(".rpm") && !name.endsWith("src.rpm"));
			}
		};
			
		String[] files = f.list(rpms);
		assertTrue("source rpms were not generated", files != null); //$NON-NLS-1$
		
		
		/* Clean up */
		testProject.getProject().delete(true, true, monitor);
	}
	
	/*
	 * @see TestCase#tearDown()
	 */
	protected void tearDown() throws Exception {
		super.tearDown();
	}
	
}




/*
 * (c) 2004 Red Hat, Inc.
 *
 * This program is open source software licensed under the 
 * Eclipse Public License ver. 1
 */
package org.eclipse.cdt.rpm.core.tests;

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.net.URL;

import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.rpm.core.SRPMExport;
import org.eclipse.cdt.rpm.core.SRPMImport;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;

import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * @author Jeremy Handcock <handcock@redhat.com>
 * 
 * This class tests the RPM plug-in's core SRPM import operation
 */
public class SRPMExportTests extends TestCase {
	IWorkspace workspace;
	IWorkspaceRoot root;
	NullProgressMonitor monitor;
	String pluginRoot;
	static final String file_sep = System.getProperty("file.separator"); //$NON-NLS-1$
	
	/**
	 * Constructor for SRPMExportTests.
	 * @param name
	 */
	public SRPMExportTests(String name) {
		super(name);
	}

	/*
	 * @see TestCase#setUp()
	 */
	protected void setUp() throws Exception {
		IWorkspaceDescription desc;
		workspace = ResourcesPlugin.getWorkspace();
		root = workspace.getRoot();
		monitor = new NullProgressMonitor();
		if(workspace == null) {
			fail("Workspace was not setup");
		}
		if(root == null) {
			fail("Workspace root was not setup");
		}
		desc = workspace.getDescription();
		desc.setAutoBuilding(false);
		workspace.setDescription(desc);
	}
	
	public static TestSuite suite() {
		return new TestSuite(SRPMExportTests.class);
	}

	public void testHelloWorldSRPMExport() throws CoreException, IOException {
		/* Create C project to use during the test */
		SRPMExportTester("helloworld", "2", "2");
	}
	
	private void SRPMExportTester(String name, String version, String release) 
		throws CoreException, IOException {
		
		/* Create C project to use during the test */
		ICProject testProject = CProjectHelper.createCProject(name, "none"); //$NON-NLS-1$ //$NON-NLS-2$
		if(testProject == null) {
			fail("Unable to create project");
		}
		
		URL url = RPMCoreTestsPlugin.getDefault().find(new Path("resources" + file_sep + "srpms" + file_sep + //$NON-NLS-1$ //$NON-NLS-2$
				name+"-"+version+"-"+release+".src.rpm"));
		if (url == null)
			fail("Unable to find resources" + file_sep + "srpms" + file_sep +
				name+"-"+version+"-"+release+".src.rpm");

		SRPMImport SRPMImport;
		SRPMImport = new SRPMImport(testProject.getProject().getLocation().
				toOSString(), Platform.asLocalURL(url).getPath());
		SRPMImport.setDoAutoconf(true);
		SRPMImport.setDoPatches(true);
		SRPMImport.run();
		/* Make sure the import was successful */
		File f = new File(testProject.getProject().getLocation().toOSString() + 
				file_sep + ".srpminfo"); //$NON-NLS-1$
		f.delete();
		f = new File(testProject.getProject().getLocation().toOSString() + 
				file_sep + "eclipse_"+name+".spec"); //$NON-NLS-1$
		f.delete();
		f = new File(testProject.getProject().getLocation().toOSString() + 
				file_sep + name+"-"+version+"-"+release+".src.rpm"); //$NON-NLS-1$
		f.delete();
		
		/* Export the SRPM */
		SRPMExport srpmExport = new SRPMExport(testProject.getProject().getLocation().toOSString());
		// set the various properties of an RPM export
		
		srpmExport.setChangelog_entry(""/** Tue Sep 14 2004 -- aluchko <aluchko@redhat.com>"*/);
		srpmExport.setPatch_tag("");
		
		
		
		srpmExport.setUi_ver_no(version);
		srpmExport.setUi_rel_no(release);
		srpmExport.setUi_spec_file("");
		
		
		srpmExport.run();
		
		f = new File(testProject.getProject().getLocation().toOSString());
		FilenameFilter rpms = new FilenameFilter() {
			public boolean accept(File dir, String name) {
				return (name.endsWith("src.rpm"));
			}
		};
		String[] files = f.list(rpms);
		assertTrue("source rpms were not generated", files != null); //$NON-NLS-1$
		
		/* Clean up */
		testProject.getProject().delete(true, true, monitor);
	}

	/*
	 * @see TestCase#tearDown()
	 */
	protected void tearDown() throws Exception {
		super.tearDown();
	}

}




/*
 * (c) 2004 Red Hat, Inc.
 *
 * This program is open source software licensed under the 
 * Eclipse Public License ver. 1
 */
package org.eclipse.cdt.rpm.core.tests;

import java.io.File;
import java.io.IOException;
import java.net.URL;

import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.rpm.core.SRPMImport;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;

/**
 * @author Jeremy Handcock <handcock@redhat.com>
 * 
 * This class tests the RPM plug-in's core SRPM import operation
 */
public class SRPMImportTests extends TestCase {
	IWorkspace workspace;
	IWorkspaceRoot root;
	NullProgressMonitor monitor;
	String pluginRoot;
	static final String file_sep = System.getProperty("file.separator"); //$NON-NLS-1$
	
	/**
	 * Constructor for SRPMImportTests.
	 * @param name
	 */
	public SRPMImportTests(String name) {
		super(name);
	}

	/*
	 * @see TestCase#setUp()
	 */
	protected void setUp() throws Exception {
		IWorkspaceDescription desc;
		workspace = ResourcesPlugin.getWorkspace();
		root = workspace.getRoot();
		monitor = new NullProgressMonitor();
		if(workspace == null) {
			fail("Workspace was not setup");
		}
		if(root == null) {
			fail("Workspace root was not setup");
		}
		desc = workspace.getDescription();
		desc.setAutoBuilding(false);
		workspace.setDescription(desc);
	}
	
	public static TestSuite suite() {
		return new TestSuite(SRPMImportTests.class);
	}

	public void testHelloWorldSRPMImport() throws CoreException, IOException {
		/* Create C project to use during the test */
		SRPMImportTester("helloworld", "2-2");
	}

	private void SRPMImportTester(String name, String version) 
		throws CoreException, IOException {

		/* Create C project to use during the test */
		ICProject testProject = CProjectHelper.createCProject(name, "none"); //$NON-NLS-1$ //$NON-NLS-2$
		if(testProject == null) {
			fail("Unable to create project");
		}
		
		URL url = RPMCoreTestsPlugin.getDefault().find(new Path("resources" + file_sep + "srpms" + file_sep + //$NON-NLS-1$ //$NON-NLS-2$
				name+"-"+version+".src.rpm"));
		if (url == null)
			fail("Unable to find resources" + file_sep + "srpms" + file_sep +
				name+"-"+version+".src.rpm");

		/* Import the SRPM */
		SRPMImport SRPMImport;
		SRPMImport = new SRPMImport(
			testProject.getProject().getLocation().toOSString(), 
			Platform.asLocalURL(url).getPath());
		SRPMImport.setDoAutoconf(true);
		SRPMImport.setDoPatches(true);
		SRPMImport.run();
		
		/* Make sure the import was successful */
		File f = new File(testProject.getProject().getLocation().toOSString() + 
			file_sep + ".srpminfo"); //$NON-NLS-1$
		assertTrue(".srpminfo not found", f != null && f.exists()); //$NON-NLS-1$
		f = new File(testProject.getProject().getLocation().toOSString() + 
			file_sep + "eclipse_"+name+".spec"); //$NON-NLS-1$
		assertTrue("spec not found", f != null && f.exists()); //$NON-NLS-1$
		f = new File(testProject.getProject().getLocation().toOSString() + 
			file_sep + name+"-"+version+".src.rpm"); //$NON-NLS-1$
		assertTrue("srpm not found", f != null && f.exists()); //$NON-NLS-1$

		/* Clean up */
		testProject.getProject().delete(true, true, monitor);
	}

	/*
	 * @see TestCase#tearDown()
	 */
	protected void tearDown() throws Exception {
		super.tearDown();
	}

}




%define _unpackaged_files_terminate_build 0
Summary: None - Eclipse-generated spec file
Name: helloworld
Version: 2
Release: 2
License: GPL
Group: Applications/Internet
Source: helloworld-%{version}.tar.bz2
Requires: tar
BuildRoot: %{_tmppath}/%{name}-root
%description

Basic spec file for rpm build in Eclipse for helloworld

%prep
%setup -q
%build

make

%install rm -rf $RPM_BUILD_ROOT
%makeinstall RPM_BUILD_ROOT=$RPM_BUILD_ROOT
%clean
rm -rf $RPM_BUILD_ROOT
%files
%defattr(-,root,root)
/usr/local/bin/helloworld
%changelog
* Tue Sep 07 2004 Rick Moseley <rmoseley@redhat.com>
- Original




/*
 * (c) 2005 Red Hat, Inc.
 *
 * This program is open source software licensed under the 
 * Eclipse Public License ver. 1
 */
package org.eclipse.cdt.rpm.core.internal.tests;

import junit.framework.Test;
import junit.framework.TestSuite;

public class RPMCoreInternalTestSuite extends TestSuite {

	public static Test suite() {
		TestSuite suite = new TestSuite(
				"Test for org.eclipse.cdt.rpm.core.internal.tests");
		//$JUnit-BEGIN$
        suite.addTest(RPMProjectTest.suite());
        suite.addTest(SpecFileParserTest.suite());
		//$JUnit-END$
		return suite;
	}
}




/*
 * (c) 2005 Red Hat, Inc.
 *
 * This program is open source software licensed under the 
 * Eclipse Public License ver. 1
 */
package org.eclipse.cdt.rpm.core.internal.tests;

import java.io.File;
import java.io.StringBufferInputStream;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Date;

import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.cdt.rpm.core.IRPMConstants;
import org.eclipse.cdt.rpm.core.IRPMProject;
import org.eclipse.cdt.rpm.core.ISpecFile;
import org.eclipse.cdt.rpm.core.RPMCorePlugin;
import org.eclipse.cdt.rpm.core.RPMExportDelta;
import org.eclipse.cdt.rpm.core.RPMProjectFactory;
import org.eclipse.cdt.rpm.core.RPMProjectNature;
import org.eclipse.cdt.rpm.core.tests.RPMCoreTestsPlugin;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.QualifiedName;

public class RPMProjectTest extends TestCase {

    IWorkspace workspace;
    IWorkspaceRoot root;
    NullProgressMonitor monitor;
    String pluginRoot;
	
    final String file_sep = System.getProperty("file.separator"); //$NON-NLS-1$
	private final String line_sep = System.getProperty("line.separator"); //$NON-NLS-1$
    
    /*
     * @see TestCase#setUp()
     */
    protected void setUp() throws Exception {
        super.setUp();
        IWorkspaceDescription desc;
        workspace = ResourcesPlugin.getWorkspace();
        root = workspace.getRoot();
        monitor = new NullProgressMonitor();
        if(workspace == null) {
            fail("Workspace was not setup");
        }
        if(root == null) {
            fail("Workspace root was not setup");
        }
        desc = workspace.getDescription();
        desc.setAutoBuilding(false);
        workspace.setDescription(desc);
    }
    
    public static TestSuite suite() {
        return new TestSuite(RPMProjectTest.class);
    }

    public void testImportHelloWorld() throws Exception {
        // Create a project for the test
        IProject testProject = root.getProject("testHelloWorld");
        testProject.create(monitor);
        testProject.open(monitor);
        if(testProject == null) {
            fail("Unable to create test project");
        }
		
		// Instantiate an RPMProject
		IRPMProject rpmProject = RPMProjectFactory.getRPMProject(testProject);
        
        // Find the test SRPM and install it
        URL url = RPMCoreTestsPlugin.getDefault().find(new Path("resources" + file_sep + "srpms" + file_sep + //$NON-NLS-1$ //$NON-NLS-2$
                "helloworld-2-2.src.rpm"));
        if (url == null) {
            fail("Unable to find resource" + file_sep + "srpms" + file_sep +
                "helloworld-2-2.src.rpm");
        }
        File foo = new File(Platform.asLocalURL(url).getPath());
        rpmProject.importSourceRPM(foo);
        
        // Make sure the original SRPM got copied into the workspace
        IFile srpm = rpmProject.getConfiguration().getSrpmsFolder().getFile("helloworld-2-2.src.rpm");
        assertTrue(srpm.exists());
		assertNotNull(rpmProject.getProject().getPersistentProperty(new QualifiedName(RPMCorePlugin.ID, 
				IRPMConstants.SRPM_PROPERTY)));
        
        // Make sure everything got installed properly
        IFile spec = rpmProject.getConfiguration().getSpecsFolder().getFile("helloworld.spec");
        assertTrue(spec.exists());
        IFile sourceBall = rpmProject.getConfiguration().getSourcesFolder().getFile("helloworld-2.tar.bz2");
        assertTrue(sourceBall.exists());

        // Make sure we got the spec file
        ISpecFile specFile = rpmProject.getSpecFile();
        assertTrue(specFile != null);
		assertNotNull(rpmProject.getProject().getPersistentProperty(new QualifiedName(RPMCorePlugin.ID,
				IRPMConstants.SPEC_FILE_PROPERTY)));
        
		// Make sure the sources got copied from BUILD to the project root
		IResource[] sources = rpmProject.getConfiguration().getBuildFolder().members();
		// If there is one folder, assume it contains all the sources
		if(sources.length == 1 && sources[0].getType() == IResource.FOLDER) {
			IFolder foo1 = rpmProject.getProject().getFolder(sources[0].getProjectRelativePath());
			sources = foo1.members();
		}
		for(int i=0; i < sources.length; i++) {
			if(sources[i].getType() == IResource.FILE) {
				assertTrue(testProject.getFile(sources[i].getName()).exists());
			}
			else if(sources[i].getType() == IResource.FOLDER) {
				assertTrue(testProject.getFolder(sources[i].getName()).exists());
			}
		}
		
		// Make sure the checksum was stored
		assertNotNull(rpmProject.getProject().getPersistentProperty(new QualifiedName(RPMCorePlugin.ID,
				IRPMConstants.CHECKSUM_PROPERTY)));
		
		// Make sure the RPM nature was added
		assertTrue(rpmProject.getProject().hasNature(RPMProjectNature.RPM_NATURE_ID));
		
        // Clean up
        testProject.delete(true, false, monitor);
    }
    
    public void testBuildPrepHelloWorld() throws Exception {
        // Create a project for the test
        IProject testProject = root.getProject("testBuildPrepHelloWorld");
        testProject.create(monitor);
        testProject.open(monitor);
        if(testProject == null) {
            fail("Unable to create test project");
        }
		
		// Instantiate an RPMProject
		IRPMProject rpmProject = RPMProjectFactory.getRPMProject(testProject);
        
        // Find the test SRPM, install, and build-prep it
        URL url = RPMCoreTestsPlugin.getDefault().find(new Path("resources" + file_sep + "srpms" + file_sep + //$NON-NLS-1$ //$NON-NLS-2$
                "helloworld-2-2.src.rpm"));
        if (url == null) {
            fail("Unable to find resource" + file_sep + "srpms" + file_sep +
                "helloworld-2-2.src.rpm");
        }
        File foo = new File(Platform.asLocalURL(url).getPath());
        rpmProject.importSourceRPM(foo);
        rpmProject.buildPrep();
        
        // Make sure we got everything in the build directory
        IFolder builddir = rpmProject.getConfiguration().getBuildFolder();
        IFolder helloworldFolder = builddir.getFolder("helloworld-2");
        assertTrue(helloworldFolder.exists());
        
        // Clean up
        testProject.delete(true, false, monitor);
    }
	
	public void testIsChangedHelloWorld() throws Exception {
		// Create a project for the test
        IProject testProject = root.getProject("testIsChangedHelloWorld");
        testProject.create(monitor);
        testProject.open(monitor);
        if(testProject == null) {
            fail("Unable to create test project");
        }
		
		// Instantiate an RPMProject
		IRPMProject rpmProject = RPMProjectFactory.getRPMProject(testProject);
        
        // Find the test SRPM and install it
        URL url = RPMCoreTestsPlugin.getDefault().find(new Path("resources" + file_sep + "srpms" + file_sep + //$NON-NLS-1$ //$NON-NLS-2$
                "helloworld-2-2.src.rpm"));
        if (url == null) {
            fail("Unable to find resource" + file_sep + "srpms" + file_sep +
                "helloworld-2-2.src.rpm");
        }
        File foo = new File(Platform.asLocalURL(url).getPath());
        rpmProject.importSourceRPM(foo);
		assertFalse(rpmProject.isChanged());
		
		testProject.delete(true, false, null);
	}
	
	public void testIsChangedHelloWorld1() throws Exception {
		// Create a project for the test
        IProject testProject = root.getProject("testIsChangedHelloWorld1");
        testProject.create(monitor);
        testProject.open(monitor);
        if(testProject == null) {
            fail("Unable to create test project");
        }
		
		// Instantiate an RPMProject
		IRPMProject rpmProject = RPMProjectFactory.getRPMProject(testProject);
        
        // Find the test SRPM and install it
        URL url = RPMCoreTestsPlugin.getDefault().find(new Path("resources" + file_sep + "srpms" + file_sep + //$NON-NLS-1$ //$NON-NLS-2$
                "helloworld-2-2.src.rpm"));
        if (url == null) {
            fail("Unable to find resource" + file_sep + "srpms" + file_sep +
                "helloworld-2-2.src.rpm");
        }
        File foo = new File(Platform.asLocalURL(url).getPath());
        rpmProject.importSourceRPM(foo);
		IFile sourceFile = rpmProject.getProject().getFile("helloworld.cpp");
		StringBufferInputStream foo1 = new StringBufferInputStream("/* */");
		sourceFile.appendContents(foo1, false, false, null);
		assertTrue(rpmProject.isChanged());
		
		testProject.delete(true, false, null);
	}
	
	public void testBuildSourceRPMHelloWorld() throws Exception {
		// Create a project for the test
        IProject testProject = root.getProject("testBuildSourceRPMHelloWorld1");
        testProject.create(monitor);
        testProject.open(monitor);
        if(testProject == null) {
            fail("Unable to create test project");
        }
		
		// Instantiate an RPMProject
		IRPMProject rpmProject = RPMProjectFactory.getRPMProject(testProject);
        
        // Find the test SRPM and install it
        URL url = RPMCoreTestsPlugin.getDefault().find(new Path("resources" + file_sep + "srpms" + file_sep + //$NON-NLS-1$ //$NON-NLS-2$
                "helloworld-2-2.src.rpm"));
        if (url == null) {
            fail("Unable to find resource" + file_sep + "srpms" + file_sep +
                "helloworld-2-2.src.rpm");
        }
        File foo = new File(Platform.asLocalURL(url).getPath());
        rpmProject.importSourceRPM(foo);
		RPMExportDelta export = new RPMExportDelta();
		export.setSpecFile(rpmProject.getSpecFile().getFile());
		export.setVersion("2");
		export.setRelease("3");
		rpmProject.buildSourceRPM(export);
		
		IFile foo2 = rpmProject.getConfiguration().getSrpmsFolder().getFile("helloworld-2-3.src.rpm");
		assertTrue(foo2.exists());
		
		testProject.delete(true, false, null);
	}
	
	public void testBuildSourceRPMHelloWorld1() throws Exception {
		// Create a project for the test
        IProject testProject = root.getProject("testBuildSourceRPMHelloWorld");
        testProject.create(monitor);
        testProject.open(monitor);
        if(testProject == null) {
            fail("Unable to create test project");
        }
		
		// Instantiate an RPMProject
		IRPMProject rpmProject = RPMProjectFactory.getRPMProject(testProject);
        
        // Find the test SRPM and install it
        URL url = RPMCoreTestsPlugin.getDefault().find(new Path("resources" + file_sep + "srpms" + file_sep + //$NON-NLS-1$ //$NON-NLS-2$
                "helloworld-2-2.src.rpm"));
        if (url == null) {
            fail("Unable to find resource" + file_sep + "srpms" + file_sep +
                "helloworld-2-2.src.rpm");
        }
        File foo = new File(Platform.asLocalURL(url).getPath());
        rpmProject.importSourceRPM(foo);
		IFile sourceFile = rpmProject.getProject().getFile("helloworld.cpp");
		StringBufferInputStream foo1 = new StringBufferInputStream("/* */");
		sourceFile.appendContents(foo1, false, false, null);
		RPMExportDelta export = new RPMExportDelta();
		export.setSpecFile(rpmProject.getSpecFile().getFile());
		export.setVersion("2");
		export.setRelease("4");
		export.setPatchName("myPatchFFFFF.patch");
		Date today = new Date();
		SimpleDateFormat df = new SimpleDateFormat("E MMM dd yyyy"); //$NON-NLS-1$
		export.setChangelogEntry("* " + df.format(today) + "  Foo Bot  <bot@foo.bar>  2-4" + line_sep + 
				"- Made test change" + line_sep);
		rpmProject.buildSourceRPM(export);
		
		// Make sure patch was created
		assertTrue(rpmProject.getConfiguration().getSourcesFolder().getFile(export.getPatchName()).exists());
		
		IFile foo2 = rpmProject.getConfiguration().getSrpmsFolder().getFile("helloworld-2-4.src.rpm");
		assertTrue(foo2.exists());
	}
}




/*
 * (c) 2005 Red Hat, Inc.
 *
 * This program is open source software licensed under the 
 * Eclipse Public License ver. 1
 */
package org.eclipse.cdt.rpm.core.internal.tests;

import java.io.File;
import java.io.FileInputStream;
import java.net.URL;

import org.eclipse.cdt.rpm.core.internal.SpecFileParser;
import org.eclipse.cdt.rpm.core.tests.RPMCoreTestsPlugin;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;

import junit.framework.TestCase;
import junit.framework.TestSuite;

public class SpecFileParserTest extends TestCase {
    
    IWorkspace workspace;
    IWorkspaceRoot root;
    NullProgressMonitor monitor;
    String pluginRoot;
    final String file_sep = System.getProperty("file.separator"); //$NON-NLS-1$
    
    public static TestSuite suite() {
        return new TestSuite(SpecFileParserTest.class);
    }
    
    /*
     * @see TestCase#setUp()
     */
    protected void setUp() throws Exception {
        super.setUp();
        IWorkspaceDescription desc;
        workspace = ResourcesPlugin.getWorkspace();
        root = workspace.getRoot();
        monitor = new NullProgressMonitor();
        if(workspace == null) {
            fail("Workspace was not setup");
        }
        if(root == null) {
            fail("Workspace root was not setup");
        }
        desc = workspace.getDescription();
        desc.setAutoBuilding(false);
        workspace.setDescription(desc);
    }

    public void testParseHelloWorld() throws Exception {
        // Create a project for the test
        IProject testProject = root.getProject("testHelloWorldSpec");
        testProject.create(monitor);
        testProject.open(monitor);
        if(testProject == null) {
            fail("Unable to create test project");
        }
        
        // Find the spec
        URL url = RPMCoreTestsPlugin.getDefault().find(new Path("resources" + file_sep + "specs" + file_sep + //$NON-NLS-1$ //$NON-NLS-2$
                "helloworld.spec"));
        if (url == null) {
            fail("Unable to find resource" + file_sep + "srpms" + file_sep +
                "helloworld.spec");
        }
        File foo = new File(Platform.asLocalURL(url).getPath());
        
        // Copy the spec into workspace
        IFile specFile = testProject.getFile("helloworld.spec");
        specFile.create(new FileInputStream(foo), false, null);
        assertTrue(specFile.exists());
        
        // Try parsing it
        SpecFileParser parser = new SpecFileParser(specFile);
        parser.parse();
        
        // Make sure we parsed the spec correctly
        String name = parser.getName();
        assertTrue(name.equals("helloworld"));
        String version = parser.getVersion();
        assertTrue(version.equals("2"));
        String release = parser.getRelease();
        assertTrue(release.equals("2"));
        assertTrue(parser.getConfigureArgs() == null);
        
        // Clean up
        testProject.delete(true, false, monitor);
    }

}




/*
 * (c) 2005 Red Hat, Inc.
 *
 * This program is open source software licensed under the 
 * Eclipse Public License ver. 1
 */

package org.eclipse.cdt.rpm.core.tests;

import org.eclipse.cdt.rpm.core.IRPMProject;
import org.eclipse.cdt.rpm.core.RPMProjectFactory;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.NullProgressMonitor;

import junit.framework.TestCase;

public class RPMProjectFactoryTest extends TestCase {
	
	IWorkspace workspace;
    IWorkspaceRoot root;
    NullProgressMonitor monitor;
    String pluginRoot;
    final String file_sep = System.getProperty("file.separator"); //$NON-NLS-1$
    
    /*
     * @see TestCase#setUp()
     */
    protected void setUp() throws Exception {
        super.setUp();
        IWorkspaceDescription desc;
        workspace = ResourcesPlugin.getWorkspace();
        root = workspace.getRoot();
        monitor = new NullProgressMonitor();
        if(workspace == null) {
            fail("Workspace was not setup");
        }
        if(root == null) {
            fail("Workspace root was not setup");
        }
        desc = workspace.getDescription();
        desc.setAutoBuilding(false);
        workspace.setDescription(desc);
    }
	
	public void testGetNewProject() throws Exception {
		// Create a project for the test
        IProject testProject = root.getProject("testHelloWorld");
        testProject.create(monitor);
        testProject.open(monitor);
        if(testProject == null) {
            fail("Unable to create test project");
        }
		
		IRPMProject rpmProject = RPMProjectFactory.getRPMProject(testProject);
		assertNotNull(rpmProject);
		testProject.delete(true, false, monitor);
	}
}




/*
 * (c) 2005 Red Hat, Inc.
 *
 * This program is open source software licensed under the 
 * Eclipse Public License ver. 1
 */

package org.eclipse.cdt.rpm.core.tests;

import org.eclipse.cdt.rpm.core.RPMProjectNature;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.NullProgressMonitor;

import junit.framework.TestCase;

public class RPMProjectNatureTest extends TestCase {

	IWorkspace workspace;
    IWorkspaceRoot root;
    NullProgressMonitor monitor;
    String pluginRoot;
    
    /*
     * @see TestCase#setUp()
     */
    protected void setUp() throws Exception {
        super.setUp();
        IWorkspaceDescription desc;
        workspace = ResourcesPlugin.getWorkspace();
        root = workspace.getRoot();
        monitor = new NullProgressMonitor();
        if(workspace == null) {
            fail("Workspace was not setup");
        }
        if(root == null) {
            fail("Workspace root was not setup");
        }
        desc = workspace.getDescription();
        desc.setAutoBuilding(false);
        workspace.setDescription(desc);
    }
	
	public void testAddRPMProjectNature() throws Exception {
		IProject testProject = root.getProject("testProject");
		testProject.create(monitor);
		testProject.open(monitor);
		if(testProject == null) {
            fail("Unable to create test project");
        }
		RPMProjectNature.addRPMNature(testProject, monitor);
		assertTrue(testProject.hasNature(RPMProjectNature.RPM_NATURE_ID));
		testProject.delete(true, false, monitor);
	}
	
}

Return to bug 82195

Removed Link Here

(-)src/org/eclipse/cdt/rpm/core/tests/CProjectHelper.java (-260 lines)
1	package org.eclipse.cdt.rpm.core.tests;
2
3	import junit.framework.Assert;
4
5	import org.eclipse.cdt.core.CCProjectNature;
6	import org.eclipse.cdt.core.CCorePlugin;
7	import org.eclipse.cdt.core.CProjectNature;
8	import org.eclipse.cdt.core.model.CModelException;
9	import org.eclipse.cdt.core.model.CoreModel;
10	import org.eclipse.cdt.core.model.IArchive;
11	import org.eclipse.cdt.core.model.IArchiveContainer;
12	import org.eclipse.cdt.core.model.IBinary;
13	import org.eclipse.cdt.core.model.IBinaryContainer;
14	import org.eclipse.cdt.core.model.ICContainer;
15	import org.eclipse.cdt.core.model.ICElement;
16	import org.eclipse.cdt.core.model.ICProject;
17	import org.eclipse.cdt.core.model.ISourceRoot;
18	import org.eclipse.cdt.core.model.ITranslationUnit;
19	import org.eclipse.core.resources.IFolder;
20	import org.eclipse.core.resources.IProject;
21	import org.eclipse.core.resources.IProjectDescription;
22	import org.eclipse.core.resources.IResource;
23	import org.eclipse.core.resources.IWorkspace;
24	import org.eclipse.core.resources.IWorkspaceRoot;
25	import org.eclipse.core.resources.IWorkspaceRunnable;
26	import org.eclipse.core.resources.ResourcesPlugin;
27	import org.eclipse.core.runtime.CoreException;
28	import org.eclipse.core.runtime.IProgressMonitor;
29	import org.eclipse.core.runtime.IStatus;
30	import org.eclipse.ui.dialogs.IOverwriteQuery;
31
32	/**
33	* Helper methods to set up a ICProject.
34	*/
35	public class CProjectHelper {
36
37	/**
38	* Creates a ICProject.
39	*/
40	public static ICProject createCProject(final String projectName, String binFolderName) throws CoreException {
41	final IWorkspace ws = ResourcesPlugin.getWorkspace();
42	final IProject newProject[] = new IProject[1];
43	ws.run(new IWorkspaceRunnable() {
44
45	public void run(IProgressMonitor monitor) throws CoreException {
46	IWorkspaceRoot root = ws.getRoot();
47	IProject project = root.getProject(projectName);
48	if (!project.exists()) {
49	project.create(null);
50	} else {
51	project.refreshLocal(IResource.DEPTH_INFINITE, null);
52	}
53	if (!project.isOpen()) {
54	project.open(null);
55	}
56	if (!project.hasNature(CProjectNature.C_NATURE_ID)) {
57	String projectId = "TestProject";
58	addNatureToProject(project, CProjectNature.C_NATURE_ID, null);
59	CCorePlugin.getDefault().mapCProjectOwner(project, projectId, false);
60	}
61	newProject[0] = project;
62	}
63	}, null);
64
65	return CCorePlugin.getDefault().getCoreModel().create(newProject[0]);
66	}
67
68	private static String getMessage(IStatus status) {
69	StringBuffer message = new StringBuffer("[");
70	message.append(status.getMessage());
71	if (status.isMultiStatus()) {
72	IStatus children[] = status.getChildren();
73	for( int i = 0; i < children.length; i++) {
74	message.append(getMessage(children[i]));
75	}
76	}
77	message.append("]");
78	return message.toString();
79	}
80
81	public static ICProject createCCProject(final String projectName, final String binFolderName) throws CoreException {
82	final IWorkspace ws = ResourcesPlugin.getWorkspace();
83	final ICProject newProject[] = new ICProject[1];
84	ws.run(new IWorkspaceRunnable() {
85
86	public void run(IProgressMonitor monitor) throws CoreException {
87	ICProject cproject = createCProject(projectName, binFolderName);
88	if (!cproject.getProject().hasNature(CCProjectNature.CC_NATURE_ID)) {
89	addNatureToProject(cproject.getProject(), CCProjectNature.CC_NATURE_ID, null);
90	}
91	newProject[0] = cproject;
92	}
93	}, null);
94	return newProject[0];
95	}
96
97	/**
98	* Removes a ICProject.
99	*/
100	public static void delete(ICProject cproject) {
101	try {
102	cproject.getProject().delete(true, true, null);
103	} catch (CoreException e) {
104	try {
105	Thread.sleep(1000);
106	} catch (InterruptedException e1) {
107	} finally {
108	try {
109	System.gc();
110	System.runFinalization();
111	cproject.getProject().delete(true, true, null);
112	} catch (CoreException e2) {
113	Assert.fail(getMessage(e2.getStatus()));
114	}
115	}
116	}
117	}
118
119	/**
120	* Adds a folder container to a ICProject.
121	*/
122	public static ICContainer addCContainer(ICProject cproject, String containerName) throws CoreException {
123	IProject project = cproject.getProject();
124	ICContainer container = null;
125	if (containerName == null \|\| containerName.length() == 0) {
126	ICContainer[] conts = cproject.getSourceRoots();
127	if (conts.length > 0) {
128	container = conts[0];
129	}
130	} else {
131	IFolder folder = project.getFolder(containerName);
132	if (!folder.exists()) {
133	folder.create(false, true, null);
134	}
135	container = CoreModel.getDefault().create(folder);
136	}
137	return container;
138	}
139
140
141	/**
142	* Removes a folder from a ICProject.
143	*/
144	public static void removeCContainer(ICProject cproject, String containerName) throws CoreException {
145	IFolder folder = cproject.getProject().getFolder(containerName);
146	folder.delete(true, null);
147	}
148
149	/**
150	* Attempts to find an archive with the given name in the workspace
151	*/
152	public static IArchive findArchive(ICProject testProject, String name) throws CModelException {
153	int x;
154	IArchive[] myArchives;
155	IArchiveContainer archCont;
156	/***************************************************************************************************************************
157	* Since ArchiveContainer.getArchives does not wait until all the archives in the project have been parsed before returning
158	* the list, we have to do a sync ArchiveContainer.getChildren first to make sure we find all the archives.
159	*/
160	archCont = testProject.getArchiveContainer();
161	myArchives = archCont.getArchives();
162	if (myArchives.length < 1)
163	return (null);
164	for (x = 0; x < myArchives.length; x++) {
165	if (myArchives[x].getElementName().equals(name))
166	return (myArchives[x]);
167	}
168	return (null);
169	}
170
171	/**
172	* Attempts to find a binary with the given name in the workspace
173	*/
174	public static IBinary findBinary(ICProject testProject, String name) throws CModelException {
175	IBinaryContainer binCont;
176	int x;
177	IBinary[] myBinaries;
178	binCont = testProject.getBinaryContainer();
179	myBinaries = binCont.getBinaries();
180	if (myBinaries.length < 1)
181	return (null);
182	for (x = 0; x < myBinaries.length; x++) {
183	if (myBinaries[x].getElementName().equals(name))
184	return (myBinaries[x]);
185	}
186	return (null);
187	}
188
189	/**
190	* Attempts to find an object with the given name in the workspace
191	*/
192	public static IBinary findObject(ICProject testProject, String name) throws CModelException {
193	ICElement[] sourceRoots = testProject.getChildren();
194	for (int i = 0; i < sourceRoots.length; i++) {
195	ISourceRoot root = (ISourceRoot) sourceRoots[i];
196	ICElement[] myElements = root.getChildren();
197	for (int x = 0; x < myElements.length; x++) {
198	if (myElements[x].getElementName().equals(name)) {
199	if (myElements[x] instanceof IBinary) {
200	return ((IBinary) myElements[x]);
201	}
202	}
203	}
204	}
205	return null;
206	}
207
208	/**
209	* Attempts to find a TranslationUnit with the given name in the workspace
210	*/
211	public static ITranslationUnit findTranslationUnit(ICProject testProject, String name) throws CModelException {
212	ICElement[] sourceRoots = testProject.getChildren();
213	for (int i = 0; i < sourceRoots.length; i++) {
214	ISourceRoot root = (ISourceRoot) sourceRoots[i];
215	ICElement[] myElements = root.getChildren();
216	for (int x = 0; x < myElements.length; x++) {
217	if (myElements[x].getElementName().equals(name)) {
218	if (myElements[x] instanceof ITranslationUnit) {
219	return ((ITranslationUnit) myElements[x]);
220	}
221	}
222	}
223	}
224	return null;
225	}
226
227	/**
228	* Attempts to find an element with the given name in the workspace
229	*/
230	public static ICElement findElement(ICProject testProject, String name) throws CModelException {
231	ICElement[] sourceRoots = testProject.getChildren();
232	for (int i = 0; i < sourceRoots.length; i++) {
233	ISourceRoot root = (ISourceRoot) sourceRoots[i];
234	ICElement[] myElements = root.getChildren();
235	for (int x = 0; x < myElements.length; x++) {
236	if (myElements[x].getElementName().equals(name)) {
237	return myElements[x];
238	}
239	}
240	}
241	return null;
242	}
243
244	private static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException {
245	IProjectDescription description = proj.getDescription();
246	String[] prevNatures = description.getNatureIds();
247	String[] newNatures = new String[prevNatures.length + 1];
248	System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
249	newNatures[prevNatures.length] = natureId;
250	description.setNatureIds(newNatures);
251	proj.setDescription(description, monitor);
252	}
253
254	private static class ImportOverwriteQuery implements IOverwriteQuery {
255
256	public String queryOverwrite(String file) {
257	return ALL;
258	}
259	}
260	}

Removed Link Here

(-)src/org/eclipse/cdt/rpm/core/tests/SRPMExportTests.java (-145 lines)
1	/*
2	* (c) 2004 Red Hat, Inc.
3	*
4	* This program is open source software licensed under the
5	* Eclipse Public License ver. 1
6	*/
7	package org.eclipse.cdt.rpm.core.tests;
8
9	import java.io.File;
10	import java.io.FilenameFilter;
11	import java.io.IOException;
12	import java.net.URL;
13
14	import org.eclipse.cdt.core.model.ICProject;
15	import org.eclipse.cdt.rpm.core.SRPMExport;
16	import org.eclipse.cdt.rpm.core.SRPMImport;
17	import org.eclipse.core.resources.IWorkspace;
18	import org.eclipse.core.resources.IWorkspaceDescription;
19	import org.eclipse.core.resources.IWorkspaceRoot;
20	import org.eclipse.core.resources.ResourcesPlugin;
21	import org.eclipse.core.runtime.CoreException;
22	import org.eclipse.core.runtime.NullProgressMonitor;
23	import org.eclipse.core.runtime.Path;
24	import org.eclipse.core.runtime.Platform;
25
26	import junit.framework.TestCase;
27	import junit.framework.TestSuite;
28
29	/**
30	* @author Jeremy Handcock <handcock@redhat.com>
31	*
32	* This class tests the RPM plug-in's core SRPM import operation
33	*/
34	public class SRPMExportTests extends TestCase {
35	IWorkspace workspace;
36	IWorkspaceRoot root;
37	NullProgressMonitor monitor;
38	String pluginRoot;
39	static final String file_sep = System.getProperty("file.separator"); //$NON-NLS-1$
40
41	/**
42	* Constructor for SRPMExportTests.
43	* @param name
44	*/
45	public SRPMExportTests(String name) {
46	super(name);
47	}
48
49	/*
50	* @see TestCase#setUp()
51	*/
52	protected void setUp() throws Exception {
53	IWorkspaceDescription desc;
54	workspace = ResourcesPlugin.getWorkspace();
55	root = workspace.getRoot();
56	monitor = new NullProgressMonitor();
57	if(workspace == null) {
58	fail("Workspace was not setup");
59	}
60	if(root == null) {
61	fail("Workspace root was not setup");
62	}
63	desc = workspace.getDescription();
64	desc.setAutoBuilding(false);
65	workspace.setDescription(desc);
66	}
67
68	public static TestSuite suite() {
69	return new TestSuite(SRPMExportTests.class);
70	}
71
72	public void testHelloWorldSRPMExport() throws CoreException, IOException {
73	/* Create C project to use during the test */
74	SRPMExportTester("helloworld", "2", "2");
75	}
76
77	private void SRPMExportTester(String name, String version, String release)
78	throws CoreException, IOException {
79
80	/* Create C project to use during the test */
81	ICProject testProject = CProjectHelper.createCProject(name, "none"); //$NON-NLS-1$ //$NON-NLS-2$
82	if(testProject == null) {
83	fail("Unable to create project");
84	}
85
86	URL url = RPMCoreTestsPlugin.getDefault().find(new Path("resources" + file_sep + "srpms" + file_sep + //$NON-NLS-1$ //$NON-NLS-2$
87	name+"-"+version+"-"+release+".src.rpm"));
88	if (url == null)
89	fail("Unable to find resources" + file_sep + "srpms" + file_sep +
90	name+"-"+version+"-"+release+".src.rpm");
91
92	SRPMImport SRPMImport;
93	SRPMImport = new SRPMImport(testProject.getProject().getLocation().
94	toOSString(), Platform.asLocalURL(url).getPath());
95	SRPMImport.setDoAutoconf(true);
96	SRPMImport.setDoPatches(true);
97	SRPMImport.run();
98	/* Make sure the import was successful */
99	File f = new File(testProject.getProject().getLocation().toOSString() +
100	file_sep + ".srpminfo"); //$NON-NLS-1$
101	f.delete();
102	f = new File(testProject.getProject().getLocation().toOSString() +
103	file_sep + "eclipse_"+name+".spec"); //$NON-NLS-1$
104	f.delete();
105	f = new File(testProject.getProject().getLocation().toOSString() +
106	file_sep + name+"-"+version+"-"+release+".src.rpm"); //$NON-NLS-1$
107	f.delete();
108
109	/* Export the SRPM */
110	SRPMExport srpmExport = new SRPMExport(testProject.getProject().getLocation().toOSString());
111	// set the various properties of an RPM export
112
113	srpmExport.setChangelog_entry(""/** Tue Sep 14 2004 -- aluchko <aluchko@redhat.com>"*/);
114	srpmExport.setPatch_tag("");
115
116
117
118	srpmExport.setUi_ver_no(version);
119	srpmExport.setUi_rel_no(release);
120	srpmExport.setUi_spec_file("");
121
122
123	srpmExport.run();
124
125	f = new File(testProject.getProject().getLocation().toOSString());
126	FilenameFilter rpms = new FilenameFilter() {
127	public boolean accept(File dir, String name) {
128	return (name.endsWith("src.rpm"));
129	}
130	};
131	String[] files = f.list(rpms);
132	assertTrue("source rpms were not generated", files != null); //$NON-NLS-1$
133
134	/* Clean up */
135	testProject.getProject().delete(true, true, monitor);
136	}
137
138	/*
139	* @see TestCase#tearDown()
140	*/
141	protected void tearDown() throws Exception {
142	super.tearDown();
143	}
144
145	}

Added Link Here

(-)resources/specs/helloworld.spec (+30 lines)
1	%define _unpackaged_files_terminate_build 0
2	Summary: None - Eclipse-generated spec file
3	Name: helloworld
4	Version: 2
5	Release: 2
6	License: GPL
7	Group: Applications/Internet
8	Source: helloworld-%{version}.tar.bz2
9	Requires: tar
10	BuildRoot: %{_tmppath}/%{name}-root
11	%description
12
13	Basic spec file for rpm build in Eclipse for helloworld
14
15	%prep
16	%setup -q
17	%build
18
19	make
20
21	%install rm -rf $RPM_BUILD_ROOT
22	%makeinstall RPM_BUILD_ROOT=$RPM_BUILD_ROOT
23	%clean
24	rm -rf $RPM_BUILD_ROOT
25	%files
26	%defattr(-,root,root)
27	/usr/local/bin/helloworld
28	%changelog
29	* Tue Sep 07 2004 Rick Moseley <rmoseley@redhat.com>
30	- Original

Added Link Here

(-)src/org/eclipse/cdt/rpm/core/internal/tests/RPMCoreInternalTestSuite.java (+23 lines)
1	/*
2	* (c) 2005 Red Hat, Inc.
3	*
4	* This program is open source software licensed under the
5	* Eclipse Public License ver. 1
6	*/
7	package org.eclipse.cdt.rpm.core.internal.tests;
8
9	import junit.framework.Test;
10	import junit.framework.TestSuite;
11
12	public class RPMCoreInternalTestSuite extends TestSuite {
13
14	public static Test suite() {
15	TestSuite suite = new TestSuite(
16	"Test for org.eclipse.cdt.rpm.core.internal.tests");
17	//$JUnit-BEGIN$
18	suite.addTest(RPMProjectTest.suite());
19	suite.addTest(SpecFileParserTest.suite());
20	//$JUnit-END$
21	return suite;
22	}
23	}