/*******************************************************************************
 * Copyright (c) 2007 BEA Systems, Inc 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
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * Contributors:
 *    BEA Systems, Inc - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.j2ee.classpath.tests;

import java.io.FileInputStream;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

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

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jst.j2ee.classpath.tests.util.ClasspathDependencyTestUtil;
import org.eclipse.jst.j2ee.classpathdep.UpdateClasspathAttributeUtil;
import org.eclipse.jst.j2ee.commonarchivecore.internal.EARFile;
import org.eclipse.jst.j2ee.commonarchivecore.internal.File;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifest;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifestImpl;
import org.eclipse.jst.j2ee.commonarchivecore.internal.impl.ArchiveImpl;
import org.eclipse.jst.j2ee.componentcore.EnterpriseArtifactEdit;
import org.eclipse.jst.j2ee.componentcore.util.EARArtifactEdit;
import org.eclipse.jst.j2ee.dependency.tests.util.DependencyCreationUtil;
import org.eclipse.jst.j2ee.dependency.tests.util.ProjectUtil;
import org.eclipse.jst.j2ee.internal.J2EEVersionConstants;
import org.eclipse.jst.j2ee.internal.classpathdep.ClasspathDependencyEnablement;
import org.eclipse.jst.j2ee.internal.deployables.J2EEFlexProjDeployable;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.server.core.IModule;
import org.eclipse.wst.server.core.model.IModuleFile;
import org.eclipse.wst.server.core.model.IModuleFolder;
import org.eclipse.wst.server.core.model.IModuleResource;
import org.eclipse.wst.server.core.util.ProjectModule;

/**
 * Tests export and publish behavior for classpath component dependencies on the module projects associated with an EAR.
 */
public class ClasspathDependencyEARTests extends AbstractTests {

	private static final String UTIL_PROJECT = "TestUtil";
	private static final String WEB_PROJECT = "TestWeb";
	private static final String EAR_PROJECT = "TestEAR";
	
    private ClasspathDependencyEARTests(final String name) {
        super(name);
    }
    
    public static Test suite(){
        final TestSuite suite = new TestSuite();
        suite.setName("Classpath Dependency EAR Tests" );
        //suite.addTest(new ClasspathDependencyEARTests("testEARExportJ2EE"));
        //suite.addTest(new ClasspathDependencyEARTests("testEARExportJEE5"));
        suite.addTest(new ClasspathDependencyEARTests("testEARPublishJ2EE"));
        suite.addTest(new ClasspathDependencyEARTests("testEARPublishJEE5"));
        //suite.addTest(new ClasspathDependencyEARTests("testEARLibPublishJEE5"));
        return suite;
    }
    
    public void testEARExportJ2EE() throws Exception {
    	testEARExport(false);
    }
    
    public void testEARExportJEE5() throws Exception {
    	testEARExport(true);
    }

    // XXX TODO need to modify test logic to work with new JEE5 model provider logic rather than just EARArtifactEdit
    private void testEARExport(boolean JEE5) throws Exception {
    	// create the EAR and module projects
    	createProjects(JEE5);
    	final IProject earProject = ProjectUtil.getProject(EAR_PROJECT);
    	final IVirtualComponent earComp = ComponentCore.createComponent(earProject);
    	final Set archiveNames = new HashSet();
    	archiveNames.add(ClasspathDependencyTestUtil.TEST1_JAR);
    	archiveNames.add(ClasspathDependencyTestUtil.TEST2_JAR);
    	
    	// verify that the exported EAR does not contain the cp container Jars from the utility,
    	// that the utility MANIFEST classpath does not include entries for the cp container jars and
    	// that the contents of the util and web "bin" class folders are not included in the exported archives.
    	verifyExportedEAR(earComp, archiveNames, false);

    	// add the attribute to the cp container and "bin" class folder in the utility project and to the "bin" class
    	// folder in the web project
    	addDependencyAttribute(true);
    	
    	// verify that the exported EAR does contain the cp container Jars from the utility,
    	// that the utility MANIFEST classpath includes entries for the cp container
    	// jars, that the utility includes the contents of the "bin" class folder and that the web's WEB-INF/classes
    	// includes the contents of the web's "bin" class folder.
    	verifyExportedEAR(earComp, archiveNames, true);
    }
    
    private void verifyExportedEAR(final IVirtualComponent comp, final Set archiveNames, final boolean shouldHaveDependencies) throws Exception {
		EnterpriseArtifactEdit earEdit = null;
		EARFile earFile = null;
		try {
			earEdit = EARArtifactEdit.getEARArtifactEditForRead(comp);
			if (earEdit != null) {
				earFile = (EARFile) earEdit.asArchive(true);
				List archives = earFile.getArchiveFiles();
				Iterator it = archiveNames.iterator();
				while (it.hasNext()) {
					String name = (String) it.next();
					boolean hasArchive = false;
					for (int i = 0; i < archives.size(); i++) {
						File archive = (File) archives.get(i);
						if (archive.isArchive()) {
							if (archive.getName().equals(name)) {
								hasArchive= true;
							}
						}
					}
					if (shouldHaveDependencies) {
						assertTrue("Exported EAR missing classpath dependency Jar " + name, hasArchive);  					
					} else {
						assertFalse("Exported EAR has unexpected classpath dependency Jar " + name, hasArchive);
					}
				}
				for (int i = 0; i < archives.size(); i++) {
					File archive = (File) archives.get(i);
					if (archive.isArchive() && archive.getName().equals(UTIL_PROJECT + ".jar")) {
						ArchiveImpl archiveImpl = (ArchiveImpl) archive;
						String[] cp = archiveImpl.getManifest().getClassPathTokenized();
						while (it.hasNext()) {
							String name = (String) it.next();
							boolean isOnCP = false;
							for (int j = 0; j < cp.length; j++) {
								if (cp[j].equals(name)) {
									isOnCP = true;
								}
							}
							if (shouldHaveDependencies) {
								assertTrue("Exported utility project MANIFEST.MF classpath in exported EAR is entry for dependency Jar " + name, isOnCP);  					
							} else {
								assertFalse("Exported utility project MANIFEST.MF classpath in exported EAR has unexpected entry for dependency Jar " + name, isOnCP);  					
							}
						}
						archiveImpl.getFiles();
						boolean hasTestFile = archiveImpl.containsFile("test");
						if (shouldHaveDependencies) {
							assertTrue("Exported utility project missing file from published/exported class folder", hasTestFile);  					
						} else {
							assertFalse("Exported utility project has unexpected entry for file from non-published/exported class folder", hasTestFile);  					
						}
						
					} else if (archive.isArchive() && archive.getName().equals(WEB_PROJECT + ".war")) {
						ArchiveImpl archiveImpl = (ArchiveImpl) archive;
						archiveImpl.getFiles();
						boolean hasTestFile = archiveImpl.containsFile("WEB-INF/classes/test");
						if (shouldHaveDependencies) {
							assertTrue("Exported web project missing file from published/exported class folder", hasTestFile);  					
						} else {
							assertFalse("Exported web project has unexpected entry for file from non-published/exported class folder", hasTestFile);
						}
					}
				}
			}
		} finally {
			if (earEdit !=null)
				earEdit.dispose();
			if(earFile != null){
				earFile.close();
			}
		}    	
    }
    
    public void testEARPublishJ2EE() throws Exception {
    	testEARPublish(false);
    }
    
    public void testEARPublishJEE5() throws Exception {
    	testEARPublish(true);
    }
    
    public void testEARLibPublishJEE5() throws Exception {
    	testEARLibPublishJEE5(true);
    }
    
    private void testEARPublish(boolean JEE5) throws Exception {

    	// create the EAR and module projects
    	createProjects(JEE5);
    	final IProject earProject = ProjectUtil.getProject(EAR_PROJECT);
    	final IVirtualComponent earComp = ComponentCore.createComponent(earProject);
    	final Set archiveNames = new HashSet();
    	archiveNames.add(ClasspathDependencyTestUtil.TEST1_JAR);
    	archiveNames.add(ClasspathDependencyTestUtil.TEST2_JAR);
    	
    	// verify that the published EAR does not contain the cp container Jars from the utility,
    	// that the utility MANIFEST classpath does not include entries for the cp container jars and
    	// that the contents of the util and web "bin" class folders are not included in the exported archives.
    	verifyPublishedEAR(earComp, archiveNames, false, JEE5);

    	// add the attribute to the cp container in the utility project
    	addDependencyAttribute(false);
    	
    	// verify that the published EAR does contain the cp container Jars from the utility,
    	// that the utility MANIFEST classpath includes entries for the cp container
    	// jars, that the utility includes the contents of the "bin" class folder and that the web's WEB-INF/classes
    	// includes the contents of the web's "bin" class folder.
    	verifyPublishedEAR(earComp, archiveNames, true, JEE5);
    }
    
    private void testEARLibPublishJEE5(boolean JEE5) throws Exception {
    	IVirtualComponent webComp = createWebProject(JEE5);
    	
    	final Set archiveNames = new HashSet();
    	archiveNames.add(ClasspathDependencyTestUtil.TEST1_JAR);
    	archiveNames.add(ClasspathDependencyTestUtil.TEST2_JAR);
    	final IProject earProject = ProjectUtil.getProject(EAR_PROJECT);
    	final IVirtualComponent earComp = ComponentCore.createComponent(earProject);
    	
    	verifyPublishedEARLibRef(earComp, archiveNames, false, JEE5);

    	addEARLibDependencyAttribute(false);
    	
    	verifyPublishedEARLibRef(earComp, archiveNames, true, JEE5);
    }
    
    private void verifyPublishedEAR(final IVirtualComponent comp, final Set archiveNames, final boolean shouldHaveDependencies, boolean isEE5) throws Exception {
    	
    	// verify that the published EAR contains the cp container jars from the Utility
    	J2EEFlexProjDeployable deployable = new J2EEFlexProjDeployable(comp.getProject(), comp);
		try {
			IModuleResource[] rootmembers = deployable.members();
			IModuleResource[] members = null;
			if (isEE5) {
				for (int i=0; i<rootmembers.length; i++) {
					String name = rootmembers[i].getName();
					if (name.equals("lib")) {
						members = ((IModuleFolder)rootmembers[i]).members();
					}
				}
			}

			if (members == null)
				members = rootmembers;
				
			Iterator it = archiveNames.iterator();						
			while (it.hasNext()) {
				String name = (String) it.next();
				boolean hasArchive = false;
				for (int i=0; i<members.length; i++) {
					if (members[i].getName().equals(name)) {
						hasArchive = true;
					}
				}
				if (shouldHaveDependencies) {
					assertTrue("Published EAR missing classpath dependency Jar " + name, hasArchive);  					
				} else {
					assertFalse("Published EAR has unexpected classpath dependency Jar " + name, hasArchive);
				}
			}
			
			// get the web and util child modules
			
			IModule utilModule = null;
			IModule webModule = null;
			IModule[] childModules = deployable.getChildModules();
			for (int i=0; i < childModules.length; i++) {
				if (childModules[i].getName().equals(UTIL_PROJECT)) {
					utilModule = childModules[i];
				} else if (childModules[i].getName().equals(WEB_PROJECT)) {
					webModule = childModules[i];
				}
			}
			
			// verify that the util module has MANIFEST.MF classpath references to the cp container jars and has the
			// class folder file

			assertNotNull("Missing entry for utility project", utilModule);

			J2EEFlexProjDeployable projectModule =(J2EEFlexProjDeployable) utilModule.loadAdapter(ProjectModule.class, null);
			IModuleResource[] moduleMembers = projectModule.members();
			ArchiveManifest manifest = null;
			boolean foundMetaInf = false;
			boolean foundTest = false;
			for (int i=0; i< moduleMembers.length; i++) {
				String name = moduleMembers[i].getName();
				if (name.equals("META-INF")) {
					foundMetaInf = true;
					IModuleResource manifestResource= ((IModuleFolder)moduleMembers[i]).members()[0];
					assertTrue(manifestResource.getModuleRelativePath().toString().equals("META-INF"));
					assertTrue("Expected MANIFEST.MF, got " + manifestResource.getName(), manifestResource.getName().equals("MANIFEST.MF"));
					java.io.File manifestFile = (java.io.File) manifestResource.getAdapter(java.io.File.class);
					if (manifestFile == null) {
						manifestFile = ((IFile) manifestResource.getAdapter(IFile.class)).getLocation().toFile();
					}
					assertNotNull(manifestFile);
					FileInputStream fis = null;
					try {
						fis = new FileInputStream(manifestFile);
						manifest = new ArchiveManifestImpl(fis);
					} finally {
						if (fis != null) {
							fis.close();
						}
					}
				} else if (name.equals("test")) {
					if (moduleMembers[i] instanceof IModuleFile) {
						foundTest = true;
					}
				}
			}
			if (!foundMetaInf) {
				assertTrue("members() failed to return META-INF for utility project module in published EAR", foundMetaInf);
			}
			
			if (shouldHaveDependencies) {
				assertTrue("Published utility project missing file from published/exported class folder", foundTest);  					
			} else {
				assertFalse("Published utility project has unexpected entry for file from non-published/exported class folder", foundTest);  					
			}

			assertNotNull("Failed to retrieve MANIFEST.MF from utility project module in published EAR", manifest);
			
			it = archiveNames.iterator();						
			while (it.hasNext()) {
				String name = (String) it.next();
				boolean isOnCP = false;
				String[] cp = manifest.getClassPathTokenized();
				for (int j = 0; j < cp.length; j++) {
					if (cp[j].equals(name)) {
						isOnCP = true;
					}
				}
				if (shouldHaveDependencies && ClasspathDependencyEnablement.isAllowClasspathComponentDependency()) {
					assertTrue("Utility project MANIFEST.MF classpath in published EAR missing entry for dependency Jar " + name, isOnCP);  					
				} else {
					assertFalse("Utility project MANIFEST.MF classpath in published EAR has unexpected entry for dependency Jar " + name, isOnCP);  					
				}
			}
			
			assertNotNull("Missing entry for web project", webModule);
		
			projectModule =(J2EEFlexProjDeployable) webModule.loadAdapter(ProjectModule.class, null);
			moduleMembers = projectModule.members();
			foundTest = false;
			for (int i=0; i< moduleMembers.length; i++) {
				if (moduleMembers[i].getName().equals("WEB-INF")) {
					IModuleResource[] webinfMembers = ((IModuleFolder)moduleMembers[i]).members();
					for (int j = 0; j < webinfMembers.length; j++) {
						if (webinfMembers[j].getName().equals("classes")) {
							IModuleResource[] classesMembers = ((IModuleFolder)webinfMembers[j]).members();
							if (classesMembers.length > 0) {
								IModuleResource test = classesMembers[0];
								if (test.getName().equals("test") && test.getModuleRelativePath().equals(new Path("WEB-INF/classes")) && test instanceof IModuleFile) {
									foundTest = true;
								}
							}
						}
					}
				}
			}
			if (shouldHaveDependencies) {
				assertTrue("Exported web project does not contain class folder file in WEB-INF/classes", foundTest);
			} else {
				assertFalse("Exported Web project should not class folder file in WEB-INF/classes", foundTest);
			}
		} catch (CoreException e) {
			e.printStackTrace();
			fail(e.getMessage());
		}    	
    }
    
private void verifyPublishedEARLibRef(final IVirtualComponent comp, final Set archiveNames, final boolean shouldHaveDependencies, boolean isEE5) throws Exception {
    	
    	J2EEFlexProjDeployable deployable = new J2EEFlexProjDeployable(comp.getProject(), comp);
		try {
			IModuleResource[] rootmembers = deployable.members();
			IModuleResource[] members = null;
			if (isEE5) {
				for (int i=0; i<rootmembers.length; i++) {
					String name = rootmembers[i].getName();
					if (name.equals("lib")) {
						members = ((IModuleFolder)rootmembers[i]).members();
					}
				}
			}

			if (members == null)
				members = rootmembers;
			
			Iterator it = archiveNames.iterator();						
			while (it.hasNext()) {
				String name = (String) it.next();
				boolean hasArchive = false;
				for (int i=0; i<members.length; i++) {
					if (members[i].getName().equals(name)) {
						hasArchive = true;
					}
				}
				if (shouldHaveDependencies) {
					assertTrue("Published EAR missing classpath dependency Jar " + name, hasArchive);  					
				} else {
					assertFalse("Published EAR has unexpected classpath dependency Jar " + name, hasArchive);
				}
			}
			
			IModule webModule = null;
			IModule[] childModules = deployable.getChildModules();
			for (int i=0; i < childModules.length; i++) {
				if (childModules[i].getName().equals(WEB_PROJECT)) {
					webModule = childModules[i];
				}
			}
			
			assertNotNull("Missing entry for web project", webModule);

			J2EEFlexProjDeployable projectModule =(J2EEFlexProjDeployable) webModule.loadAdapter(ProjectModule.class, null);
			IModuleResource[] moduleMembers = projectModule.members();
			ArchiveManifest manifest = null;
			boolean foundMetaInf = false;
			for (int i=0; i< moduleMembers.length; i++) {
				String name = moduleMembers[i].getName();
				if (name.equals("META-INF")) {
					foundMetaInf = true;
					IModuleResource manifestResource= ((IModuleFolder)moduleMembers[i]).members()[0];
					assertTrue(manifestResource.getModuleRelativePath().toString().equals("META-INF"));
					assertTrue("Expected MANIFEST.MF, got " + manifestResource.getName(), manifestResource.getName().equals("MANIFEST.MF"));
					java.io.File manifestFile = (java.io.File) manifestResource.getAdapter(java.io.File.class);
					if (manifestFile == null) {
						manifestFile = ((IFile) manifestResource.getAdapter(IFile.class)).getLocation().toFile();
					}
					assertNotNull(manifestFile);
					FileInputStream fis = null;
					try {
						fis = new FileInputStream(manifestFile);
						manifest = new ArchiveManifestImpl(fis);
					} finally {
						if (fis != null) {
							fis.close();
						}
					}
				} 
			}
			if (!foundMetaInf) {
				assertTrue("members() failed to return META-INF for web project module in published EAR", foundMetaInf);
			}
			
			assertNotNull("Failed to retrieve MANIFEST.MF from web project module in published EAR", manifest);
			
			it = archiveNames.iterator();						
			while (it.hasNext()) {
				String name = (String) it.next();
				boolean isOnCP = false;
				String[] cp = manifest.getClassPathTokenized();
				for (int j = 0; j < cp.length; j++) {
					if (cp[j].equals("lib/" + name)) {
						isOnCP = true;
					}
				}
				if (shouldHaveDependencies && ClasspathDependencyEnablement.isAllowClasspathComponentDependency()) {
					assertTrue("Utility project MANIFEST.MF classpath in published EAR missing entry for dependency Jar " + name, isOnCP);  					
				} else {
					assertFalse("Utility project MANIFEST.MF classpath in published EAR has unexpected entry for dependency Jar " + name, isOnCP);  					
				}
			}
			
		} catch (CoreException e) {
			e.printStackTrace();
			fail(e.getMessage());
		}    	
    }
    
    private IVirtualComponent createProjects(boolean JEE5) throws Exception {

    	// create a Web project
    	int version = J2EEVersionConstants.SERVLET_2_5;
    	if (!JEE5) {
    		version = J2EEVersionConstants.SERVLET_2_4;
    	}
    	final IProject webProject = ProjectUtil.createWebProject(WEB_PROJECT, EAR_PROJECT, version, true);
    	final IJavaProject webJavaProject = JavaCore.create(webProject);
    	final IVirtualComponent webComp = ComponentCore.createComponent(webProject);
    	// create a new "bin" folder
    	final IPath binPath = new Path("bin");
    	IFolder webBin = webProject.getFolder(binPath);
    	webBin.create(true, true, null);
    	// add a file
    	webBin.getFile("test").create(new java.io.StringBufferInputStream("blah"), true, null);
    	// add as a library cp entry
    	ClasspathDependencyTestUtil.addLibraryEntry(webJavaProject, webBin.getFullPath(), true);
    	
    	// create a Utility project
    	final IProject util = ProjectUtil.createUtilityProject(UTIL_PROJECT, EAR_PROJECT, true);
    	IFolder output = util.getFolder("build").getFolder("classes");
    	final IJavaProject utilJava = JavaCore.create(util);
    	// create a folder "bin"
    	IFolder utilBin = util.getFolder(binPath);
    	utilBin.create(true, true, null);
    	// add a file
    	utilBin.getFile("test").create(new java.io.StringBufferInputStream("blah"), true, null);
    	final IVirtualComponent utilComp = ComponentCore.createComponent(util);
    	// add as a library cp entry
    	ClasspathDependencyTestUtil.addLibraryEntry(utilJava, utilBin.getFullPath(), true);
    	
    	// add a dependency from the Web to the Utility
    	DependencyCreationUtil.createModuleDependency(webProject, util); 
    	
    	// add a cp dependency to the Utility
    	ClasspathDependencyTestUtil.addCustomClasspathContainer(utilJava);
    	
    	return webComp;
    }
    
    private IVirtualComponent createWebProject(boolean JEE5) throws Exception {
    	// create a Web project
    	int version = J2EEVersionConstants.SERVLET_2_5;
    	if (!JEE5) {
    		version = J2EEVersionConstants.SERVLET_2_4;
    	}
    	final IProject webProject = ProjectUtil.createWebProject(WEB_PROJECT, EAR_PROJECT, version, true);
    	final IJavaProject webJavaProject = JavaCore.create(webProject);
    	final IVirtualComponent webComp = ComponentCore.createComponent(webProject);
 	
    	// add a cp dependency to the Utility
    	ClasspathDependencyTestUtil.addCustomClasspathContainer(webJavaProject);
    	
    	return webComp;
    }
   
  
    /**
     * 
     * @param verifyClasspathDependencies - true if you want to immediately verify that
     * the classpath dependencies were added.  Set to false if you want to verify this at
     * a later time (such as thru a members call in export or publish).  
     * @throws Exception
     */
    private void addDependencyAttribute(boolean verifyClasspathDependencies) throws Exception {
    	final IProject util = ProjectUtil.getProject(UTIL_PROJECT);
    	final IPath fullUtilBinPath = util.getFullPath().append("bin");
    	final IJavaProject utilJava = JavaCore.create(util);
    	final IVirtualComponent utilComp = ComponentCore.createComponent(util);
    	final IProject web = ProjectUtil.getProject(WEB_PROJECT);
    	final IJavaProject webJava = JavaCore.create(web);
    	final IPath fullWebBinPath = web.getFullPath().append("bin");
    	final IVirtualComponent webComp = ComponentCore.createComponent(web);
    	
    	final Set entryPaths = new HashSet();
    	entryPaths.add(ClasspathDependencyTestUtil.CUSTOM_CLASSPATH_CONTAINER);
    	entryPaths.add(fullUtilBinPath);
    	// verify that "bin" and the custom cp container are potential entries
    	List entries = ClasspathDependencyTestUtil.verifyPotentialClasspathEntries(utilJava, entryPaths);
    	// verify that no entries have the classpath attribute
    	ClasspathDependencyTestUtil.verifyNoClasspathAttributes(utilJava);
    	// verify that there are no classpath dependencies
    	ClasspathDependencyTestUtil.verifyNoClasspathDependencies(utilComp);
    	IClasspathEntry entry = (IClasspathEntry) entries.get(0);

    	// add the dependency attribute to "bin" and the cp container    	
    	for (Object o: entries) {
    		UpdateClasspathAttributeUtil.addDependencyAttribute(null, util.getName(), (IClasspathEntry) o);
    	}
    	// should no longer have potential entries
    	ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(utilJava);
    	// verify that "bin" and the cp container have the attribute
    	ClasspathDependencyTestUtil.verifyClasspathAttributes(utilJava, entryPaths);
    	// verify that "bin" and the cp container are dependencies
    	final Set archiveNames = new HashSet();
    	archiveNames.add(ClasspathDependencyTestUtil.TEST1_JAR);
    	archiveNames.add(ClasspathDependencyTestUtil.TEST2_JAR);
    	archiveNames.add(fullUtilBinPath.toString());
    	if (verifyClasspathDependencies)
    		ClasspathDependencyTestUtil.verifyClasspathDependencies(utilComp, archiveNames);
    	
    	entryPaths.clear();
    	entryPaths.add(fullWebBinPath);
    	// verify that "bin" in the web project is a potential entry
    	entries = ClasspathDependencyTestUtil.verifyPotentialClasspathEntries(webJava, entryPaths);
    	// verify that no entries have the classpath attribute
    	ClasspathDependencyTestUtil.verifyNoClasspathAttributes(webJava);
    	// verify that there are no classpath dependencies
    	ClasspathDependencyTestUtil.verifyNoClasspathDependencies(webComp);
    	
    	// add the dependency attribute to "bin"
    	entry = (IClasspathEntry) entries.get(0);
    	UpdateClasspathAttributeUtil.addDependencyAttribute(null, web.getName(), entry);
    	// should no longer have potential entries
    	ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(webJava);
    	// verify that "bin" has the attribute
    	ClasspathDependencyTestUtil.verifyClasspathAttributes(webJava, entryPaths);
    	// verify that "bin" is a dependency
    	archiveNames.clear();
    	archiveNames.add(fullWebBinPath.toString());
    	if (verifyClasspathDependencies)
    		ClasspathDependencyTestUtil.verifyClasspathDependencies(webComp, archiveNames);
    }
    
    /**
     * 
     * @param verifyClasspathDependencies - true if you want to immediately verify that
     * the classpath dependencies were added.  Set to false if you want to verify this at
     * a later time (such as thru a members call in export or publish)  
     * @throws Exception
     */
    private void addEARLibDependencyAttribute(boolean verifyClasspathDependencies) throws Exception {

    	final IProject web = ProjectUtil.getProject(WEB_PROJECT);
    	final IJavaProject webJava = JavaCore.create(web);
    	final IVirtualComponent webComp = ComponentCore.createComponent(web);
    	
    	final Set entryPaths = new HashSet();
    	entryPaths.add(ClasspathDependencyTestUtil.CUSTOM_CLASSPATH_CONTAINER);
    	// verify that "bin" and the custom cp container are potential entries
    	List entries = ClasspathDependencyTestUtil.verifyPotentialClasspathEntries(webJava, entryPaths);
    	// verify that no entries have the classpath attribute
    	ClasspathDependencyTestUtil.verifyNoClasspathAttributes(webJava);
    	// verify that there are no classpath dependencies
    	ClasspathDependencyTestUtil.verifyNoClasspathDependencies(webComp);
    	IClasspathEntry entry = (IClasspathEntry) entries.get(0);

    	// add the dependency attribute to "bin" and the cp container    	
    	for (Object o: entries) {
    		UpdateClasspathAttributeUtil.addDependencyAttribute(null, web.getName(), (IClasspathEntry) o, new Path("../lib"));
    	}
    	// should no longer have potential entries
    	ClasspathDependencyTestUtil.verifyNoPotentialClasspathEntries(webJava);
    	// verify that "bin" and the cp container have the attribute
    	ClasspathDependencyTestUtil.verifyClasspathAttributes(webJava, entryPaths);
    	// verify that "bin" and the cp container are dependencies
    	final Set archiveNames = new HashSet();
    	archiveNames.add(ClasspathDependencyTestUtil.TEST1_JAR);
    	archiveNames.add(ClasspathDependencyTestUtil.TEST2_JAR);
    	if (verifyClasspathDependencies)
    		ClasspathDependencyTestUtil.verifyClasspathDependencies(webComp, archiveNames);
    }
}