Attachment #117601 for bug #249588

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

/**

 * 
 * @author  Peter Sun
 * @author  Paul E. Slauenwhite
 * @version November 11, 2008
 * @since   February 1, 2005
 */
public class DatapoolCSVImportPage extends WizardPage implements ModifyListener, SelectionListener {

		return;
	}

	protected void validateSelection(){
		
		//Note: The error message is not initially reset to reduce flicker when setting the same error message.		
		boolean isValid = false;
		String csvFileName = getCSVFileName();		

		if((csvFileName != null) && (csvFileName.trim().length() > 0)){			

			Shell shell = getShell();
			
			//Set the wait cursor:
			shell.setCursor(new Cursor(shell.getDisplay(), SWT.CURSOR_WAIT));

			try{
				isValid = CSVImportExportUtil.getInstance().validateCSVFile(csvFileName, firstRowContainsVariableNameType(), firstColumnContainsEquivalenceClassName(), getImportEncoding());				
			}
			catch(Exception e){
				setErrorMessage(e.getMessage());
			}		
			finally{
					
				//Set the default cursor:
				shell.setCursor(null);
			}
			
			if(isValid){
				setErrorMessage(null);	
			}
		}
		
		setPageComplete(isValid);
		getContainer().updateButtons();		
		return isCSVValid;
	}
}




 *******************************************************************************/
package org.eclipse.hyades.test.ui.internal.wizard;

import org.eclipse.hyades.test.ui.datapool.internal.util.CSVImportExportUtil;
import org.eclipse.swt.widgets.Composite;

/**

 * 
 * @author  Bianca Xue Jiang
 * @author  Paul E. Slauenwhite
 * @version November 11, 2008
 * @since   March 23, 2005
 */
public class DatapoolImportPage extends DatapoolCSVImportPage {

		setControl(parentComposite);
		validateSelection();
	}
	
	protected boolean validateSelection()
	{
		boolean valid = false;
		setMessage(null);
		setErrorMessage(null);
		
		String csvFile = getCSVFileName();
		
		try{
			if((csvFile != null) && (csvFile.length() > 0)){			
				valid = CSVImportExportUtil.getInstance().validateCSVFile(csvFile, firstRowContainsVariableNameType(), firstColumnContainsEquivalenceClassName(), getImportEncoding());             
			}
		}
		catch(Exception e){
			valid = false;
			setErrorMessage(e.getMessage());
		}		
		
		setPageComplete(valid);
		getContainer().updateButtons();
		
		return valid;
	}
}




import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Shell;

/**
 * Datapool CSV import page two.
 * 
 * 
 * @author  Paul E. Slauenwhite
 * @version November 11, 2008
 * @since   October 31, 2008
 */
public class DatapoolImportPageTwo extends DatapoolSelectionPage {

				//Validate the selected datapool:
				if(selectedDatapool != null){

					Shell shell = getShell();
					
					//Set the wait cursor:
					shell.setCursor(new Cursor(shell.getDisplay(), SWT.CURSOR_WAIT));

					try {

						DatapoolImportPage datapoolImportPage = ((DatapoolImportWizard)(getWizard())).getDatapoolImportPage();

					catch(Exception e) {
						setErrorMessage(e.getMessage());
					}	
					finally{
						
						//Set the default cursor:
						shell.setCursor(null);
					}
				}
			}
		}




 * 
 * @author  Bianca Xue Jiang
 * @author  Paul E. Slauenwhite
 * @version November 11, 2008
 * @since   March 18, 2005
 */
public class DatapoolImportWizard extends Wizard implements IImportWizard {

	 */
	public boolean performFinish() {

		IRunnableWithProgress operation = new WorkspaceModifyOperation() {

			public void execute(IProgressMonitor monitor) throws InvocationTargetException {

				monitor.beginTask(UiPluginResourceBundle.DatapoolImportWizard_progressMonitor, 4);

				//Resolve the selected datapool:
				IDatapool datapool = datapoolImportPageTwo.getSelectedDatapool();
				boolean isEncrypted = datapoolImportPageTwo.isSelectedDatapoolEncrypted();
				String password = datapoolImportPageTwo.getEncryptedDatapoolPassword();

				try {

					monitor.worked(1);

					if(datapool != null){

						if(isEncrypted){
							DatapoolEncryptManager.decryptDatapool(datapool, password);
						}

						//Empty the datapool if it contains only an empty default cell:
						if(CSVImportExportUtil.getInstance().isDefaultEmptyDatapool(datapool)){

							datapool.removeVariable(0);
							datapool.removeEquivalenceClass(0);
						}
					}    				
					else {

						//Assumption:  The file name will include the file extension (see org.eclipse.tptp.platform.common.ui.wizard.LocationPage.getFileName()).
						String datapoolFileName = locationPage.getFileName();

						//Create a new datapool:
						datapool = ((DPLDatapool)(DatapoolUtil.createNewDatapool(datapoolFileName.substring(0, datapoolFileName.indexOf('.')), null)));

						//Create the resource and add the datapool:
						EMFUtil.getResourceFactory(locationPage.getFileExtension()).createResource(URI.createPlatformResourceURI(locationPage.getContainerFullPath().append(datapoolFileName).toOSString(), false)).getContents().add(datapool);
					}

					monitor.worked(1);

					if(datapool.getVariableCount() == 0){

						//Import the CSV file to the datapool:
						CSVImportExportUtil.getInstance().importCSV(datapool, 
								datapoolImportPage.getCSVFileName(), 
								datapoolImportPage.firstRowContainsVariableNameType(),
								datapoolImportPage.firstColumnContainsEquivalenceClassName(),
								datapoolImportPage.getImportEncoding());
					}
					else{

						//Append the CSV file to the datapool:
						CSVImportExportUtil.getInstance().appendFromCSV(datapool, 
								datapoolImportPage.getCSVFileName(), 
								datapoolImportPage.firstRowContainsVariableNameType(),
								datapoolImportPage.firstColumnContainsEquivalenceClassName(),
								datapoolImportPage.getImportEncoding());
					}

					monitor.worked(1);

					Resource datapoolResource = ((EObject)(datapool)).eResource();

					//Save (or serialize) the datapool resource to the workspace:
					EMFUtil.save(datapoolResource);

					//Attempt to open the editor:
					TestUIUtilities.openEditor(datapoolResource, TestUIExtension.DATAPOOL_EDITOR_PART_ID);

					monitor.worked(1);
				}
				catch(Exception e){

					UiPlugin.logError(e);			

					new ErrorDialog(getShell(), 
							UiPluginResourceBundle.WIZ_DATAPOOL_CSV_ERRDLG_TITLE,
							UiPluginResourceBundle._ERROR_WIZ_DATAPOOL_CSV_ERRDLG_IMPFILE,
							new Status(IStatus.ERROR,
									UiPlugin.PLUGIN_ID,
									IStatus.OK,
									e.toString(),
									e),
									IStatus.ERROR).open();
				}
				finally{

					//Encrypted the datapool if decrypted: 
					if(isEncrypted){		
						DatapoolEncryptManager.encryptDatapool(datapool, password);
					}

					monitor.done();		
    			}
    			finally{
                    monitor.done();		
    			}
    		}
        };
        
        try {
        	String key = datapoolImportPageTwo.getEncryptedDatapoolPasswordText().getText();
        	IDatapool datapool = datapoolImportPageTwo.getSelectedDatapool();
			if(datapoolImportPageTwo.isEncrypted()){
				if(!DatapoolEncryptManager.isKeyCorrect(datapool, key)){
					datapoolImportPageTwo.setMessage(UiPluginResourceBundle.DatapoolExportWizard_wrongpass,3);
					datapoolImportPageTwo.getEncryptedDatapoolPasswordText().setText("");
					datapoolImportPageTwo.getEncryptedDatapoolPasswordText().setFocus();
					return false;
				}
			}
		};

		try {        	
			getContainer().run(false, false, operation);
		} 
		catch (InvocationTargetException e) {
			UiPlugin.logError(e);
		} 
		catch (InterruptedException e) {
			//Ignore since the operation cannot be canceled.
		}

		return true;
	}
}




package org.eclipse.hyades.test.ui.internal.wizard;

import java.io.File;
import java.io.IOException;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.hyades.edit.datapool.IDatapool;
import org.eclipse.hyades.models.common.datapool.util.DatapoolEncryptManager;
import org.eclipse.hyades.test.ui.TestUI;
import org.eclipse.hyades.test.ui.TestUIImages;
import org.eclipse.hyades.test.ui.UiPlugin;
import org.eclipse.hyades.test.ui.datapool.internal.util.CSVImportExportUtil;
import org.eclipse.hyades.test.ui.internal.resources.UiPluginResourceBundle;
import org.eclipse.hyades.test.ui.util.TestUIUtil;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IExportWizard;
import org.eclipse.ui.IWorkbench;



 * @author  Peter Sun
 * @author  Paul E. Slauenwhite
 * @version November 11, 2008
 * @since   February 1, 2005
 */
public class DatapoolExportWizard extends Wizard implements IExportWizard {

	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.IWizard#performFinish()
	 */	
	public boolean performFinish() {

		//Resolve the selected datapool:
		//Assumption: The datapool is not null.
		IDatapool datapool = datapoolSelectionPage.getSelectedDatapool();
		boolean isEncrypted = datapoolSelectionPage.isSelectedDatapoolEncrypted();
		String password = datapoolSelectionPage.getEncryptedDatapoolPassword();

		try {

			//Decrypt the datapool if encrypted: 
			if(isEncrypted){		
				DatapoolEncryptManager.decryptDatapool(datapool, password);
			}

			//Resolve the CSV file:
			String csvFileName = TestUIUtil.validateExtension(csvFileLocationPage.getCSVFileName().trim(), TestUI.CSV_FILE_EXTENSION);

			if (new File(csvFileName).exists()){

				MessageDialog overwriteDialog = new MessageDialog(getShell(),
						UiPluginResourceBundle.WIZ_EXP_DATAPOOL_TTL, 
						null,
						NLS.bind(UiPluginResourceBundle.WIZ_EXP_DATAPOOL_MSG_EXISTS, csvFileName), 
						MessageDialog.WARNING, 
						new String[] {IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL}, 
						0);

				//Return if cannot replace existing CSV file:
				if (overwriteDialog.open() != IDialogConstants.OK_ID){
					return false;
				}
			}

			//Export the datapool to the CSV file:
			CSVImportExportUtil.getInstance().exportCSV(datapool, csvFileName, 
					csvFileLocationPage.getExportVariables(), 
					csvFileLocationPage.getExportEquivalenceClassNames(), 
					csvFileLocationPage.getExportTags(), 
					csvFileLocationPage.getExportEncoding());

			//Refresh the CSV file if exported to the workspace:
			IFile[] files = ResourcesPlugin.getWorkspace().getRoot().findFilesForLocation(new Path(csvFileName));

			for (int counter = 0; counter < files.length; counter++) {

				try {
					files[counter].refreshLocal(0, null);
				} 
				catch (CoreException e) {
					UiPlugin.logError(e);
				}
			}

			return true;
		}
		catch (IOException i) {
			ErrorDialog.openError(Display.getCurrent().getActiveShell(), UiPluginResourceBundle.W_ERROR, null, new Status(IStatus.ERROR, UiPlugin.getID(), IResourceStatus.ERROR, i.getMessage(), i));
		if( DatapoolEncryptManager.isDatapoolEncrypted(datapool))
		{
			DatapoolEncryptManager.decryptDatapool(datapool, key);
		}
		finally{
		if(!csvFileName.endsWith(".csv") && !csvFileName.endsWith(".CSV"))
			csvFileName = csvFileName + ".csv";

			//Encrypted the datapool if decrypted: 
			if(isEncrypted){		
				DatapoolEncryptManager.encryptDatapool(datapool, password);
			}
			String message = NLS.bind(UiPluginResourceBundle.WIZ_EXP_DATAPOOL_MSG_EXISTS, csvFileName);
			MessageDialog overwriteDialog = new MessageDialog(getShell(),
															  UiPluginResourceBundle.WIZ_EXP_DATAPOOL_TTL, 
															  null,
															  message, 
															  MessageDialog.WARNING, 
															  new String[] {IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL}, 
															  0);
			
			// user selected - "don't replace", return false
			if (overwriteDialog.open() != 0)
				return false;
		}
		
		return false;
		boolean exportEqClsNames = csvFileLocationPage.getExportEquivalenceClassNames();
		boolean exportTags = csvFileLocationPage.getExportTags();
		String exportEncoding = csvFileLocationPage.getExportEncoding();
		boolean close = CSVImportExportUtil.getInstance().exportCSV(datapool, csvFileName, exportVariables, exportEqClsNames, exportTags, exportEncoding);
        IFile[] files = ResourcesPlugin.getWorkspace().getRoot().findFilesForLocation(new Path(csvFileName));
        for (int i = 0; i < files.length; i++) {
            try {
                files[i].refreshLocal(0, null);
            } catch (CoreException e) {
                UiPlugin.logError(e);
            }
        }
        
        //encrypted datapool again after finish export it  
        if( DatapoolEncryptManager.isDatapoolEncrypted(datapool))
		{
			DatapoolEncryptManager.encryptDatapool(datapool, key);
		}
        return close;
	}
}




 * 
 * 
 * @author  Paul E. Slauenwhite
 * @version November 11, 2008
 * @since   October 31, 2008
 */
public class DatapoolSelectionPage extends WizardPage {

	private Text encryptedDatapoolPasswordText = null;	
	private IStructuredSelection selection = null;
	private IDatapool selectedDatapool = null;
	private boolean isSelectedDatapoolEncrypted = false;

	public DatapoolSelectionPage(String name){
		this(name, null);

				super.setSelection();
				
				selectedDatapool = null;
				isSelectedDatapoolEncrypted = false;
				
				IProxyNode[] selectedProxyNodes = datapoolSelectionViewer.getSelectedProxyNodes();


						selectedDatapool = ((IDatapool)(eObject));

						//Determine if the selected datapool is encrypted:
						isSelectedDatapoolEncrypted = DatapoolEncryptManager.isDatapoolEncrypted(selectedDatapool);

						if((isSelectedDatapoolEncrypted) && (!encryptedDatapoolPasswordGroup.isVisible())){
						encryptedDatapoolPasswordGroup.setVisible(isEncrypted);						

						if(isEncrypted){
						
							//Set the title of the encrypted datapool password group:
							encryptedDatapoolPasswordGroup.setText(NLS.bind(UiPluginResourceBundle.DatapoolExportWizard_password, selectedDatapool.getName()));

							encryptedDatapoolPasswordText.setText("");
							encryptedDatapoolPasswordText.setFocus();				
						}
						
						//Show or hide the encrypted datapool password group:
						encryptedDatapoolPasswordGroup.setVisible(isSelectedDatapoolEncrypted);						
					}
				}
				

		encryptedDatapoolPasswordText.addModifyListener(new ModifyListener(){
			
			public void modifyText(ModifyEvent e){
				setPageComplete(validatePage());
				if(encryptedDatapoolPasswordText.getText().trim().length() > 0){

					setErrorMessage(null);

					setPageComplete(true);
				}
				else {

					setErrorMessage(NLS.bind(UiPluginResourceBundle.DatapoolExportWizard_encrypted, selectedDatapool.getName()));

					setPageComplete(false);
				}
			}
		});


	public IDatapool getSelectedDatapool(){
		return selectedDatapool;
	}

	public Text getEncryptedDatapoolPasswordText(){
		return encryptedDatapoolPasswordText;
	}
	
	public boolean isSelectedDatapoolEncrypted(){
		return isSelectedDatapoolEncrypted;
	}	

	public String getEncryptedDatapoolPassword(){
		return (encryptedDatapoolPasswordText.getText().trim());
	}

	protected boolean validatePage() {
		
		//Note: The error message is not initially reset to reduce flicker when setting the same error message.		

		if(selectedDatapool != null){

			//Validate the selected encrypted datapool and its password:
			if(isSelectedDatapoolEncrypted){

				String password = getEncryptedDatapoolPassword();

				if(password.length() == 0){

					setErrorMessage(NLS.bind(UiPluginResourceBundle.DatapoolExportWizard_encrypted, selectedDatapool.getName()));

					//Set focus to the encrypted datapool password:				
					encryptedDatapoolPasswordText.setFocus();
				}
				else if(!DatapoolEncryptManager.isKeyCorrect(selectedDatapool, password)){

					setErrorMessage(UiPluginResourceBundle.DatapoolExportWizard_wrongpass);

					//Set focus to the encrypted datapool password:				
					encryptedDatapoolPasswordText.setFocus();
				}
				else{					
					isValid = true;
				}
			}
			else{

				isValid = true;

				setErrorMessage(null);
			}
		}

		if(isValid){
			setErrorMessage(null);			
		}

		return isValid;
	}	
}




import java.util.List;
import java.util.Map;

import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.hyades.edit.datapool.IDatapool;
import org.eclipse.hyades.edit.datapool.IDatapoolCell;
import org.eclipse.hyades.edit.datapool.IDatapoolEquivalenceClass;
import org.eclipse.hyades.edit.datapool.IDatapoolRecord;
import org.eclipse.hyades.edit.datapool.IDatapoolSuggestedType;
import org.eclipse.hyades.edit.datapool.IDatapoolVariable;
import org.eclipse.hyades.test.ui.UiPlugin;
import org.eclipse.hyades.test.ui.datapool.util.DatapoolUtilities;
import org.eclipse.hyades.test.ui.internal.resources.UiPluginResourceBundle;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Display;

import com.ibm.icu.text.NumberFormat;

/**
 * CSV import and export utilities.

 * @author  Peter Sun
 * @author  Bianca Xue Jiang
 * @author  Paul E. Slauenwhite
 * @author  Jerome Bozier
 * @version November 11, 2008
 * @since   January 27, 2005
 */
public class CSVImportExportUtil 


	private static final CSVImportExportUtil instance = new CSVImportExportUtil();

	private static long lineCounter = 1;
	
	public static CSVImportExportUtil getInstance()
	{
		return instance;
	}
	
	/**
	 * Private constructor.
	 */
	private CSVImportExportUtil(){
		//No-operation.
	}
	
	/**
	 * <p>Validates a Comma Separated Values (CSV) file containing datapool records.</p>
	 * 
	 * <p>Validation is required when importing a CSV file into a new or existing datapool.</p>
	 * 
	 * @param  csvFilePath The absolute path of the CSV file.
	 * @param  isFirstRowVariableInfo If the first row of the CSV file contains the variable information (name/type), otherwise <code>false</code>.
	 * @param  isFirstColumnEquivalenceClassInfo If the first column of the CSV file contains the equivalence class information (name/row index), otherwise <code>false</code>.
	 * @param  encoding The encoding of the CSV file, otherwise <code>null</null>.
	 * @return <code>true</code> if the CSV file is valid, otherwise <code>false</code>.
	 * @throws FileNotFoundException The CSV file could not be found.
	 * @throws IOException An error occurs while reading the CSV file.
	 * @throws CorruptCSVFileException The CSV is invalid.
	 * @see    #importCSV(IDatapool, String, boolean, boolean, String)
	 * @see    #importCSV(IDatapool, String, boolean, boolean, String, int, int)
	 * @see    #appendFromCSV(IDatapool, String, boolean, boolean, String)
	 */
	public boolean validateCSVFile(String csvFilePath, 
			boolean isFirstRowVariableInfo, 
			boolean isFirstColumnEquivalenceClassInfo, 
			String encoding) throws FileNotFoundException, IOException, CorruptCSVFileException {
		return (validateCSVFileWithDatapool(csvFilePath, null, isFirstRowVariableInfo, isFirstColumnEquivalenceClassInfo, encoding));
	}
	
	/**
	 * <p>Validates a Comma Separated Values (CSV) file containing datapool records against a datapool.</p>
	 * 
	 * <p>Validation is required when importing a CSV file into a new or existing datapool.</p>
	 * 
	 * @param  csvFilePath The absolute path of the CSV file.
	 * @param  datapool The datapool that the CSV file is validated against, otherwise <code>null</null>.
	 * @param  isFirstRowVariableInfo If the first row of the CSV file contains the variable information (name/type), otherwise <code>false</code>.
	 * @param  isFirstColumnEquivalenceClassInfo If the first column of the CSV file contains the equivalence class information (name/row index), otherwise <code>false</code>.
	 * @param  encoding The encoding of the CSV file, otherwise <code>null</null>.
	 * @return <code>true</code> if the CSV file is valid, otherwise <code>false</code>.
	 * @throws FileNotFoundException The CSV file could not be found.
	 * @throws IOException An error occurs while reading the CSV file.
	 * @throws CorruptCSVFileException The CSV is invalid.
	 * @see    #importCSV(IDatapool, String, boolean, boolean, String)
	 * @see    #importCSV(IDatapool, String, boolean, boolean, String, int, int)
	 * @see    #appendFromCSV(IDatapool, String, boolean, boolean, String)
	 */
	public boolean validateCSVFileWithDatapool(String csvFilePath, 
			IDatapool datapool, 
			boolean isFirstRowVariableInfo, 
			boolean isFirstColumnEquivalenceClassInfo, 
			String encoding) throws FileNotFoundException, IOException, CorruptCSVFileException {

		//Determine if the datapool should be validated :
		boolean validateDatapool = ((datapool != null) && (datapool.getVariableCount() > 0) && (!isDefaultEmptyDatapool(datapool)));
		
		//Resolve the input reader:
		BufferedReader lineReader = null;
        
		try {
			lineReader = new BufferedReader(new InputStreamReader(new FileInputStream(fullyQualifiedCSVName)));
        } 
		else {
			lineReader = new BufferedReader(new InputStreamReader(new FileInputStream(fullyQualifiedCSVName), encoding));
        }
		
		//Read the first line:
		String line = lineReader.readLine();
		int lineCount = 1;
		int variableCount = -1;
		
		//Check if the first line is empty:
		if((line == null) || (line.trim().length() == 0)){
			throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount),UiPluginResourceBundle.DATA_COL_DLG_ERROR_MISSING_CVS_LINE}));	
		}

		//Validate the variable names and optional suggested types in the first row:
		if(isFirstRowVariableInfo){
		
			//Parse the first row containing the variable names and optional suggested types:
			CSVTokenizer tokenizer = new CSVTokenizer(line);
			
			if((encoding == null) || (encoding.trim().length() == 0)) {
				lineReader = new BufferedReader(new InputStreamReader(new FileInputStream(csvFilePath)));
	        } 
			else {
				lineReader = new BufferedReader(new InputStreamReader(new FileInputStream(csvFilePath), encoding));
	        }
			
			//Read the first line:
			String line = lineReader.readLine();
			int lineCount = 1;
			int variableCount = -1;
			
			if(validateDatapool){
				variableCount = datapool.getVariableCount();
							
				//Resolve the variable name:
				String suggestedType = null;
				String variableName = tokenizer.nextToken().trim();
				int twoColonsIndex = variableName.indexOf(CSVTokenizer.TWO_COLONS); 

				//Resolve the optional suggested type within the variable name:
				if(twoColonsIndex != -1){					

					suggestedType = variableName.substring(twoColonsIndex + CSVTokenizer.TWO_COLONS.length()).trim();
					variableName = variableName.substring(0, twoColonsIndex).trim();
				}

				//Validate the variable name:
				if(variableName.length() == 0){
					throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DATA_COL_DLG_ERROR_MISSING_VARIABLE}));	
				}
				else if(!DatapoolUtilities.getInstance().isVariableNameValid(variableName)){
					throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DATA_COL_DLG_ERROR_NAME_NOT_VALID}));	
				}				
				else if(variableNames.contains(variableName)){
					throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DATA_COL_DLG_ERROR_NAME_NOT_UNIQUE}));	
				}
				else{
					variableNames.add(variableName);
				}

				//Validate the optional suggested type:
				if((suggestedType !=  null) && (!DatapoolUtilities.getInstance().isVariableTypeValid(suggestedType))){
					throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DATA_COL_DLG_ERROR_TYPE_NOT_VALID}));	
				}
			}
			
			//Check if the first line is empty:
			if((line == null) || (line.trim().length() == 0)){
				throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount),UiPluginResourceBundle.DATA_COL_DLG_ERROR_MISSING_CVS_LINE}));	
			if(variableCount == 0){
				throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount),UiPluginResourceBundle.DATA_COL_DLG_ERROR_MISSING_VARIABLE}));									
			}
	
			//Validate the variable names and optional suggested types in the first row:
			if(isFirstRowVariableInfo){
			
				//Parse the first row containing the variable names and optional suggested types:
			lineCount++;
		}

		Map equivalenceClassNames = new HashMap();
		String defaultEquivalenceClassName = null;
		int emptyLineCount = 0;

		//Validate the remaining lines:
		while(line != null){

			//Validate the next line that is not empty:
			if(line.trim().length() > 0){

				//Parse the row containing the remaining columns:
				CSVTokenizer tokenizer = new CSVTokenizer(line);
				
				//Check if the first column is the equivalence class cell (e.g. empty value):
				if((isFirstColumnEquivalenceClassInfo) && ((!tokenizer.hasMoreTokens()) || (tokenizer.nextToken().trim().length() > 0))){
					throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount),UiPluginResourceBundle.DATA_COL_DLG_ERROR_MISSING_EQUIVALENCE}));	
				}
				
				List variableNames = new ArrayList();
				
				//Iterate the columns containing the variable names and optional suggested types:
				while(tokenizer.hasMoreTokens()){
								
					//Resolve the variable name:
					String suggestedType = null;
					String variableName = tokenizer.nextToken().trim();
					int twoColonsIndex = variableName.indexOf(CSVTokenizer.TWO_COLONS); 
	
					//Resolve the optional suggested type within the variable name:
					if(twoColonsIndex != -1){					
	
						suggestedType = variableName.substring(twoColonsIndex + CSVTokenizer.TWO_COLONS.length()).trim();
						variableName = variableName.substring(0, twoColonsIndex).trim();
					}

					//Validate the equivalence class name:
					if(equivalenceClassName.length() == 0){
						throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DATA_COL_DLG_ERROR_MISSING_EQUIVALENCE}));	
					}
					
					//Validate the variable name:
					if(variableName.length() == 0){
						throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DATA_COL_DLG_ERROR_MISSING_VARIABLE}));	
					}
					else if(!DatapoolUtilities.getInstance().isVariableNameValid(variableName)){
						throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DATA_COL_DLG_ERROR_NAME_NOT_VALID}));	
					}				
					else if(variableNames.contains(variableName)){
						throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DATA_COL_DLG_ERROR_NAME_NOT_UNIQUE}));	
					}
					else{
						variableNames.add(variableName);
						equivalenceClassNames.put(equivalenceClassName, new Integer(0));

						if(defaultEquivalenceClassName == null){
							defaultEquivalenceClassName = equivalenceClassName;
						}
					}
					
					//Validate the optional suggested type:
					if((suggestedType !=  null) && (!DatapoolUtilities.getInstance().isVariableTypeValid(suggestedType))){
						throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DATA_COL_DLG_ERROR_TYPE_NOT_VALID}));	
						equivalenceClassNames.put(defaultEquivalenceClassName, new Integer(((Integer)(equivalenceClassNames.get(defaultEquivalenceClassName))).intValue() + emptyLineCount));

						emptyLineCount = 0;
					}
										
					//Validate the variable name and optional suggested type against the datapool:
					if(validateDatapool){
	
						try {
							
							org.eclipse.hyades.execution.runtime.datapool.IDatapoolVariable variable = datapool.getVariable(variableNames.size() - 1);
	
							if((!variableName.equals(variable.getName())) || ((suggestedType != null) && (!TypeChecker.getInstance().isTypeMatch(suggestedType, variable.getSuggestedType())))){
								throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DatapoolImportWizard_diffVariableInfoWarning}));	
							}
						} 
						catch (Exception e) {
							throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DatapoolImportWizard_diffVariableInfoWarning}));	
						}
					}
				}
				
				int columnCount = variableNames.size();
				
				//Check if any variables were validated:
				if(columnCount == 0){
					throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount),UiPluginResourceBundle.DATA_COL_DLG_ERROR_MISSING_VARIABLE}));
					columnCount++;

					tokenizer.nextToken();
				}
				
				if(variableCount == -1){
					variableCount = columnCount;
				}
				else if(columnCount != variableCount){
					throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), NLS.bind(UiPluginResourceBundle.DATA_COL_DLG_ERROR_INCONSISTENT_COLUMN_COUNT, String.valueOf(columnCount))}));					
				}
				
				line = lineReader.readLine();
				lineCount++;
			}
	
			Map equivalenceClassNames = new HashMap();
			String defaultEquivalenceClassName = null;
			int emptyLineCount = 0;
	
			//Validate the remaining lines:
			while(line != null){
	
				//Validate the next line that is not empty:
				if(line.trim().length() > 0){
	
					//Parse the row containing the remaining columns:
					CSVTokenizer tokenizer = new CSVTokenizer(line);
	
					//Validate the equivalence class names and optional row numbers in the first column:
					if(isFirstColumnEquivalenceClassInfo){
	
						//Resolve the equivalence class name:					
						String rowNumber = null;
						String equivalenceClassName = tokenizer.nextToken().trim();
						int twoColonsIndex = equivalenceClassName.indexOf(CSVTokenizer.TWO_COLONS); 
	
						//Resolve the optional row number within the equivalence class name:
						if(twoColonsIndex != -1){					
	
							rowNumber = equivalenceClassName.substring(twoColonsIndex + CSVTokenizer.TWO_COLONS.length()).trim();
							equivalenceClassName = equivalenceClassName.substring(0, twoColonsIndex).trim();
						}
	
						//Validate the equivalence class name:
						if(equivalenceClassName.length() == 0){
							throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DATA_COL_DLG_ERROR_MISSING_EQUIVALENCE}));	
						}
						else if(!DatapoolUtilities.getInstance().isEquivalenceClassNameValid(equivalenceClassName)){
							throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), UiPluginResourceBundle.DATA_ROW_GRP_DLG_ERROR_NAME_NOT_VALID}));	
						}
						else if(equivalenceClassNames.containsKey(equivalenceClassName)){					
							equivalenceClassNames.put(equivalenceClassName, new Integer(((Integer)(equivalenceClassNames.get(equivalenceClassName))).intValue() + 1));						
						}
						else{

							int recordCount = 0;
							
							//Resolve the record count from the equivalence class:
							if(validateDatapool){
								
								org.eclipse.hyades.execution.runtime.datapool.IDatapoolEquivalenceClass equivalenceClass = datapool.getEquivalenceClass(datapool.getEquivalenceClassIndex(equivalenceClassName));
								
								if(equivalenceClass != null){
									recordCount = equivalenceClass.getRecordCount();
								}
							}

							equivalenceClassNames.put(equivalenceClassName, new Integer(recordCount));

							if(defaultEquivalenceClassName == null){
								defaultEquivalenceClassName = equivalenceClassName;
							}
						}
	
						//Count the empty lines as empty rows for the default equivalence class:
						if(emptyLineCount > 0){
	
							equivalenceClassNames.put(defaultEquivalenceClassName, new Integer(((Integer)(equivalenceClassNames.get(defaultEquivalenceClassName))).intValue() + emptyLineCount));
	
							emptyLineCount = 0;
						}
	
						//Validate the optional row number:
						if(rowNumber !=  null){
	
							try {
	
								int recordIndex = Integer.parseInt(rowNumber);
								
								if(recordIndex > (((Integer)(equivalenceClassNames.get(equivalenceClassName))).intValue())){
									throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), NLS.bind(UiPluginResourceBundle.DATA_COL_DLG_ERROR_INCONSISTENT_ROW_ORDER, rowNumber)}));	
								}		
								else if(validateDatapool){
									
									org.eclipse.hyades.execution.runtime.datapool.IDatapoolEquivalenceClass equivalenceClass = datapool.getEquivalenceClass(datapool.getEquivalenceClassIndex(equivalenceClassName));
									
									if((equivalenceClass != null) && (recordIndex < equivalenceClass.getRecordCount()) && (equivalenceClass.getRecord(recordIndex) != null)){
										throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[] {String.valueOf(lineCount), UiPluginResourceBundle.DATA_CSV_ERROR_RECORD_INDEX_DUP}));										
									}
								}
							} 
							catch (NumberFormatException n) {
								throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), NLS.bind(UiPluginResourceBundle.DATA_COL_DLG_ERROR_INVALID_ROW_COUNT, rowNumber)}));	
							}
						}
					}
	
					//Validate the number of remaining columns:		
					int columnCount = 0;
	
					while(tokenizer.hasMoreTokens()){
	
						columnCount++;
	
						tokenizer.nextToken();
					}
	
					if(variableCount == -1){
						variableCount = columnCount;
					}
					else if(columnCount != variableCount){
						throw new CorruptCSVFileException(NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, new String[]{String.valueOf(lineCount), NLS.bind(UiPluginResourceBundle.DATA_COL_DLG_ERROR_INCONSISTENT_COLUMN_COUNT, String.valueOf(columnCount))}));	
					}
				}
				else{
					emptyLineCount++;
				}
	
				line = lineReader.readLine();
				lineCount++;
			}
						
			return true;
		}
		finally{
	
			//Close the input reader:
			try {
				lineReader.close();			
			} 
			catch (IOException i) {
				//Ignore since closing input reader.
			}
			
			org.eclipse.hyades.execution.runtime.datapool.IDatapoolVariable variable = datapool.getVariable(i);
			if(!name.equals(variable.getName()))
				return false;
			
			if(type.length() > 0 && !TypeChecker.getInstance().isTypeMatch(type, variable.getSuggestedType()))
				return false;
		}
		
		return true;
	}
	
	/**
	 * <p>Determines if a datapool is empty.</p>
	 * 
	 * <p>Empty datapools have exactly one of the following:</p>
	 * 
	 * <ul>
	 * <li>equivalence class</li>
	 * <li>variable</li>
	 * <li>record</li>
	 * <li>cell</li>
	 * </ul>
	 * 
	 * <p>In addition, the cell has no associated value.</p>
	 * 
	 * @param datapool The datapool to be evaluated.
	 * @return <code>true</code> if the datapool is empty, otherwise <code>false</code>.
	 */
	public boolean isDefaultEmptyDatapool(IDatapool datapool)
	{
		if(datapool.getVariableCount() == 1 && datapool.getEquivalenceClassCount() == 1)

		return false;
	}
		
	/**
	 * <p>Imports a Comma Separated Values (CSV) file into a datapool.</p>
	 * 
	 * <p><b>Note</b>: The CSV file is assumed to be valid.  To validate the CSV file 
	 * with the datapool, call the {@link #validateCSVFileWithDatapool(String, IDatapool, boolean, boolean, String)}
	 * method.</p>
	 * 
	 * @param  datapool The datapool that the CSV file is imported into.
	 * @param  csvFilePath The absolute path of the CSV file.
	 * @param  isFirstRowVariableInfo If the first row of the CSV file contains the variable information (name/type), otherwise <code>false</code>.
	 * @param  isFirstColumnEquivalenceClassInfo If the first column of the CSV file contains the equivalence class information (name/row index), otherwise <code>false</code>.
	 * @param  encoding The encoding of the CSV file, otherwise <code>null</null>.
	 * @throws IOException An error occurs while reading the CSV file.
	 * @see    #validateCSVFileWithDatapool(String, IDatapool, boolean, boolean, String)
	 */
	public void importCSV(IDatapool datapool, 
			String csvFileName, 
			boolean isFirstRowVariableInfo, 
			boolean isFirstColumnEquivalenceClassInfo,
			String encoding)throws IOException {
				throws IOException, CorruptCSVFileException
	{
		importCSV(datapool, 
				csvFileName, 
				isFirstRowVariableInfo, 
				isFirstColumnEquivalenceClassInfo,
				encoding, 
				-1, 
				-1);
	}
				
	/**
	 * <p>Imports a Comma Separated Values (CSV) file into a datapool.</p>
	 * 
	 * <p><b>Note</b>: The CSV file is assumed to be valid.  To validate the CSV file 
	 * with the datapool, call the {@link #validateCSVFileWithDatapool(String, IDatapool, boolean, boolean, String)}
	 * method.</p>
	 * 
	 * @param  datapool The datapool that the CSV file is imported into.
	 * @param  csvFilePath The absolute path of the CSV file.
	 * @param  isFirstRowVariableInfo If the first row of the CSV file contains the variable information (name/type), otherwise <code>false</code>.
	 * @param  isFirstColumnEquivalenceClassInfo If the first column of the CSV file contains the equivalence class information (name/row index), otherwise <code>false</code>.
	 * @param  encoding The encoding of the CSV file, otherwise <code>null</null>.
	 * @param  numberOfColumns The number of columns of the CSV file to import into the datapool, otherwise <code>-1</code>.
	 * @param  numberOfRows The number of rows of the CSV file to import into the datapool, otherwise <code>-1</code>.
	 * @throws IOException An error occurs while reading the CSV file.
	 * @see    #validateCSVFileWithDatapool(String, IDatapool, boolean, boolean, String)
	 */
	public void importCSV(IDatapool datapool, 
			String csvFilePath, 
			boolean isFirstRowVariableInfo, 
			boolean isFirstColumnEquivalenceClassInfo, 
			String encoding, 
			int numberOfColumns, 
			int numberOfRows) throws IOException{
			throws IOException, CorruptCSVFileException
	{
		if(datapool == null || csvFileName == null)
			return;
		
		if((datapool != null) && (csvFilePath != null)){
		
			BufferedReader bufferedReader = null;

			try{			
					
				if((encoding != null) && (encoding.trim().length() > 0)){
					bufferedReader = new CSVBufferedReader(new InputStreamReader(new FileInputStream(csvFilePath), (encoding.trim())));
				}
				else{
					bufferedReader = new CSVBufferedReader(new InputStreamReader(new FileInputStream(csvFilePath)));
				}
					
				String line = bufferedReader.readLine();

				//Initialize to 1 since once line has already been read:
				int lineCounter = 1;

				if(isFirstRowVariableInfo){
					
					createVariablesFromFile(datapool, line, lineCounter, isFirstColumnEquivalenceClassInfo, numberOfColumns);
					
					line = bufferedReader.readLine();
					
					lineCounter++;
				}
				else{
					createVariables(datapool, line, isFirstColumnEquivalenceClassInfo, numberOfColumns);
				}
				
				int recordCounter = 0;
				
				while((line != null) && ((numberOfRows == -1) || (recordCounter < numberOfRows))){
					
					createRecord(datapool, line, lineCounter, isFirstColumnEquivalenceClassInfo);
					
					recordCounter++;
					
					line = bufferedReader.readLine();
					
					lineCounter++;
				}
			}
			finally{
				
				try {

					if(bufferedReader != null){
						bufferedReader.close();
					}
				} 
				catch (IOException i) {
					//Ignore since closing input stream reader.
				}
			}
			bufferedReader.close();
		}
		catch(IOException e)
		{
			throw e;
		}
		catch(CorruptCSVFileException e)
		{
			throw e;
		}
		finally
		{
			lineCounter = 1;
		}
	}
	
	/**
	 * <p>Appends a Comma Separated Values (CSV) file to a datapool.</p>
	 * 
	 * <p><b>Note</b>: The CSV file is assumed to be valid.  To validate the CSV file 
	 * with the datapool, call the {@link #validateCSVFileWithDatapool(String, IDatapool, boolean, boolean, String)}
	 * method.</p>
	 * 
	 * @param  datapool The datapool that the CSV file is appended to.
	 * @param  csvFilePath The absolute path of the CSV file.
	 * @param  isFirstRowVariableInfo If the first row of the CSV file contains the variable information (name/type), otherwise <code>false</code>.
	 * @param  isFirstColumnEquivalenceClassInfo If the first column of the CSV file contains the equivalence class information (name/row index), otherwise <code>false</code>.
	 * @param  encoding The encoding of the CSV file, otherwise <code>null</null>.
	 * @throws IOException An error occurs while reading the CSV file.
	 * @see    #validateCSVFileWithDatapool(String, IDatapool, boolean, boolean, String)
	 */
	public void appendFromCSV(IDatapool datapool, 
							String csvFilePath, 
							boolean isFirstRowVariableInfo, 
							boolean isFirstColumnEquivalenceClassInfo,
							String encoding) throws IOException {
		throws IOException, CorruptCSVFileException
	{
		if(datapool == null || csvFileName == null)
			return;
		
		if((datapool != null) && (csvFilePath != null)){
			
			BufferedReader bufferedReader = null;

			try{			
					
				if((encoding != null) && (encoding.trim().length() > 0)){
					bufferedReader = new CSVBufferedReader(new InputStreamReader(new FileInputStream(csvFilePath), (encoding.trim())));
				}
				else{
					bufferedReader = new CSVBufferedReader(new InputStreamReader(new FileInputStream(csvFilePath)));
				}
					
				String line = bufferedReader.readLine();

				//Initialize to 1 since once line has already been read:
				int lineCounter = 1;

				if(isFirstRowVariableInfo){
					
					line = bufferedReader.readLine();
					
					lineCounter++;
				}
				
				while(line != null){
					
					createRecord(datapool, line, lineCounter, isFirstColumnEquivalenceClassInfo);
										
					line = bufferedReader.readLine();
					
					lineCounter++;
				}
			}
			finally{
				
				try {

					if(bufferedReader != null){
						bufferedReader.close();
					}
				} 
				catch (IOException i) {
					//Ignore since closing input stream reader.
				}
			}
			bufferedReader.close();
		}
		catch(IOException e)
		{
			throw e;
		}
		catch(CorruptCSVFileException e)
		{
			throw e;
		}
		finally
		{
			lineCounter = 1;
		}
	}
	
	/**
	 * <p>Exports a datapool to a Comma Separated Values (CSV) file.</p>
	 * 
	 * @param  datapool The datapool that is exported to the CSV file.
	 * @param  csvFilePath The absolute path of the CSV file.
	 * @param  includeVariableInfo If the first row of the CSV file contains the variable information (name/type), otherwise <code>false</code>.
	 * @param  includeEquivalenceClassInfo If the first column of the CSV file contains the equivalence class information (name/row index), otherwise <code>false</code>.
	 * @param  includeTags If the cell values are enclosed in tags, otherwise <code>false</code>.
	 * @param  encoding The encoding of the CSV file, otherwise <code>null</null>.
	 * @throws IOException An error occurs while writing the CSV file.
	 */
	public void exportCSV(IDatapool datapool, 
							String csvFilePath, 
							boolean includeVariableInfo, 
							boolean includeEquivalenceClassInfo,
							boolean includeTags,
							String encoding) throws IOException{
		
		if((datapool != null) && (csvFilePath != null)){
			
			BufferedWriter bufferedWriter = null;

			try{			
					
				if((encoding != null) && (encoding.trim().length() > 0)){
					bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(csvFilePath), (encoding.trim())));
				}
				else{
					bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(csvFilePath)));
				}
					
				if(includeVariableInfo){
					writeVariables(datapool, bufferedWriter, true, includeEquivalenceClassInfo);
				}
				
				writeRecords(datapool, bufferedWriter, includeEquivalenceClassInfo, includeTags);
			}
			finally{
				
				try {

					if(bufferedWriter != null){
						bufferedWriter.close();
					}
				} 
				catch (IOException i) {
					//Ignore since closing input stream reader.
				}
			}
		}
		finally
		{
			lineCounter = 1;
		}		
		return true;
	}
	
	private void createVariablesFromFile(IDatapool datapool, String variableString, int lineNumber, boolean ignoreFirst, int numberOfColumns)
	{
		boolean first = true;
		int counter = 1;

				type = nameTypePair.substring(separatorIndex + 2);
			}
			
			
			{
				Object[] messageElements = {String.valueOf(lineCounter), 
											UiPluginResourceBundle.DATA_COL_DLG_ERROR_NAME_NOT_UNIQUE}; 
				String error = NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, messageElements); 
				throw new CorruptCSVFileException(error);				
			}
			if(!DatapoolUtilities.getInstance().isVariableNameValid(name))
			{
				Object[] messageElements = {String.valueOf(lineCounter), 
											UiPluginResourceBundle.DATA_COL_DLG_ERROR_NAME_NOT_VALID}; 
				String error = NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, messageElements); 
				throw new CorruptCSVFileException(error);				
				
			}
			if(!DatapoolUtilities.getInstance().isVariableTypeValid(type))
			{
				Object[] messageElements = {String.valueOf(lineCounter), 
											UiPluginResourceBundle.DATA_COL_DLG_ERROR_TYPE_NOT_VALID}; 
				String error = NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, messageElements); 
				throw new CorruptCSVFileException(error);				
			}
			IDatapoolVariable variable = datapool.constructVariable();
			variable.setName(name);
			IDatapoolSuggestedType suggestedType = (IDatapoolSuggestedType)variable.getSuggestedType();

		}
	}
	
	private void createRecord(IDatapool datapool, String recordString, int lineNumber, boolean useSpecifiedEquivalenceClass) {

		CSVTokenizer tokenizer = new CSVTokenizer(recordString);
		IDatapoolEquivalenceClass equivalenceClass = null;
		String recordIndexStr = null;
		int recordIndex = -1;
		
		//Note: Check if the current token is not empty since the tokenizer returns empty tokens.
		if((useSpecifiedEquivalenceClass) && (tokenizer.hasMoreTokens()) && (tokenizer.currentToken().trim().length() > 0)){

			String equivalenceClassName = tokenizer.nextToken();
			int separatorIndex = equivalenceClassName.indexOf(CSVTokenizer.TWO_COLONS); 
			
			if(separatorIndex != -1){
				
				try{
					recordIndex = Integer.parseInt(equivalenceClassName.substring(separatorIndex + CSVTokenizer.TWO_COLONS.length()));
					recordIndexStr = ecName.substring(separatorIndex + 2);
					Number number = NumberFormat.getInstance().parse(recordIndexStr);
					recordIndex = number.intValue();
				}
				catch(NumberFormatException n){
					//Ignore and append the record. 
				}
				
				equivalenceClassName = equivalenceClassName.substring(0, separatorIndex);
			}
						
			int equivalenceClassIndex = datapool.getEquivalenceClassIndex(equivalenceClassName);
			
			if(equivalenceClassIndex == -1){

				Object[] messageElements = {String.valueOf(lineCounter), 
											UiPluginResourceBundle.DATA_ROW_GRP_DLG_ERROR_NAME_NOT_VALID}; 
				String error = NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, messageElements); 
				throw new CorruptCSVFileException(error);								
			}
			int ecIndex = datapool.getEquivalenceClassIndex(ecName);
			if(ecIndex >= 0)
				equivalenceClass = (IDatapoolEquivalenceClass)datapool.getEquivalenceClass(ecIndex);
			else
			{
				equivalenceClass = datapool.constructEquivalenceClass();
				equivalenceClass.setName(equivalenceClassName);
				
				datapool.appendEquivalenceClass(equivalenceClass);
			}
			else{
				equivalenceClass = ((IDatapoolEquivalenceClass)(datapool.getEquivalenceClass(equivalenceClassIndex)));
			}		
		}
		else{
			
			//By default, import all records into the default equivalence class:
			if(datapool.getEquivalenceClassCount() == 0){
				
				equivalenceClass = datapool.constructEquivalenceClass();
				
				datapool.appendEquivalenceClass(equivalenceClass);
			}
			else{				
				equivalenceClass = (IDatapoolEquivalenceClass)datapool.getEquivalenceClass(Math.max(0, datapool.getDefaultEquivalenceClassIndex()));
				int defaultIndex = datapool.getDefaultEquivalenceClassIndex();
				defaultIndex = defaultIndex < 0 ? 0 : defaultIndex;
				equivalenceClass = (IDatapoolEquivalenceClass)datapool.getEquivalenceClass(defaultIndex);
			}
		}
		List cellValues = new ArrayList();
		while(tokenizer.hasMoreTokens())
		{
			String cellValue = tokenizer.nextToken();
			cellValues.add(cellValue);
		}
		
		//Resolve the remaining cells from the record:
		List cells = new ArrayList();
		
		while(tokenizer.hasMoreTokens()){
			cells.add(tokenizer.nextToken());
		}
		
		IDatapoolRecord record = equivalenceClass.constructRecord(((String[])(cells.toArray(new String[cells.size()]))));
		int recordCount = equivalenceClass.getRecordCount();
		
		if((recordIndex > -1) && (recordIndex < recordCount) && (equivalenceClass.getRecord(recordIndex) == null)){
			equivalenceClass.insertRecord(record, recordIndex);				
				existingRecord = (IDatapoolRecord)equivalenceClass.getRecord(recordIndex);
			}
			catch(Exception e)
			{
			}
			if(existingRecord != null)
			{
				Object[] messageElements = {String.valueOf(lineCounter), 
											UiPluginResourceBundle.DATA_CSV_ERROR_RECORD_INDEX_DUP}; 
				String error = NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, messageElements); 
				throw new CorruptCSVFileException(error);												
			}
			if(recordIndex > equivalenceClass.getRecordCount())
			{
				Object[] messageElements = {String.valueOf(lineCounter), 
											UiPluginResourceBundle.DATA_CSV_ERROR_RECORD_INDEX_ORDER}; 
				String error = NLS.bind(UiPluginResourceBundle.DATA_CSV_LINE, messageElements); 
				throw new CorruptCSVFileException(error);																
			}
			else
				equivalenceClass.insertRecord(record, recordIndex);
		}
		else{
			equivalenceClass.appendRecord(record);
		}
	}
	
	private void writeVariables(IDatapool datapool, BufferedWriter writer, boolean includeTypes, boolean includeEquivalenceClasses)

Lines 19-25 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/resources/UiPluginResourceBundle.java (-2 / +1 lines)
19	*	19	*
20	*	20	*
21	* @author Paul E. Slauenwhite	21	* @author Paul E. Slauenwhite
22	* @version August 7, 2008	22	* @version November 11, 2008
23	* @since March 15, 2007	23	* @since March 15, 2007
24	*/	24	*/
25	public final class UiPluginResourceBundle extends NLS {	25	public final class UiPluginResourceBundle extends NLS {
Lines 216-222 Link Here
216	public static String DATA_DLG_FIRST_ELEMENT;	216	public static String DATA_DLG_FIRST_ELEMENT;
217	public static String DATA_CSV_LINE;	217	public static String DATA_CSV_LINE;
218	public static String DATA_CSV_ERROR_RECORD_INDEX_DUP;	218	public static String DATA_CSV_ERROR_RECORD_INDEX_DUP;
219	public static String DATA_CSV_ERROR_RECORD_INDEX_ORDER;
220	public static String DATA_DEL_VAR_DLG_TITLE;	219	public static String DATA_DEL_VAR_DLG_TITLE;
221	public static String DATA_DEL_VAR_DLG_SEL;	220	public static String DATA_DEL_VAR_DLG_SEL;
222	public static String DATA_ADD_ROW_OPTION_BEFORE;	221	public static String DATA_ADD_ROW_OPTION_BEFORE;

Lines 270-277 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/resources/messages.properties (-2 lines)
270	DATA_CSV_LINE = CSV file line {0}: {1}	270	DATA_CSV_LINE = CSV file line {0}: {1}
271	#IWAT0221E	271	#IWAT0221E
272	DATA_CSV_ERROR_RECORD_INDEX_DUP = Duplicate record.	272	DATA_CSV_ERROR_RECORD_INDEX_DUP = Duplicate record.
273	#IWAT0222E
274	DATA_CSV_ERROR_RECORD_INDEX_ORDER = Record not in proper order.
275		273
276	# Delete Variable Dialog	274	# Delete Variable Dialog
277	DATA_DEL_VAR_DLG_TITLE = Delete Variable	275	DATA_DEL_VAR_DLG_TITLE = Delete Variable

Lines 16-22 Link Here

(-)src-test/org/eclipse/hyades/models/common/datapool/impl/messages.properties (-1 lines)
16	Common_DatapoolFactoryImpl.23=IWAT3058E Error while accessing iterator	16	Common_DatapoolFactoryImpl.23=IWAT3058E Error while accessing iterator
17	Common_DatapoolFactoryImpl.25=IWAT3059E Datapool Iterator could not be opened	17	Common_DatapoolFactoryImpl.25=IWAT3059E Datapool Iterator could not be opened
18	Common_DatapoolFactoryImpl.26=IWAT3060E Datapool Iterator could not be opened	18	Common_DatapoolFactoryImpl.26=IWAT3060E Datapool Iterator could not be opened
19	DPLCellImpl.18 =IWAT3061E No extensions found for tag
20	DPLEquivalenceClassImpl.1 =IWAT3062E Attempt to enter duplicate records into an equivalence class	19	DPLEquivalenceClassImpl.1 =IWAT3062E Attempt to enter duplicate records into an equivalence class
21	DPLEquivalenceClassImpl.2 =IWAT3063E Record reordering attempt with wrong number of records specified	20	DPLEquivalenceClassImpl.2 =IWAT3063E Record reordering attempt with wrong number of records specified
22	DPLRecordImpl.1 =IWAT3064E Nonexistent Variable Index Used	21	DPLRecordImpl.1 =IWAT3064E Nonexistent Variable Index Used

Lines 17-22 Link Here

(-)src-test/org/eclipse/hyades/models/common/datapool/impl/DPLCellImpl.java (-102 / +91 lines)
17	package org.eclipse.hyades.models.common.datapool.impl;	17	package org.eclipse.hyades.models.common.datapool.impl;
18		18
19	import java.util.Map;	19	import java.util.Map;
		20	import java.util.regex.Matcher;
		21	import java.util.regex.Pattern;
20		22
21	import org.eclipse.emf.common.notify.Notification;	23	import org.eclipse.emf.common.notify.Notification;
22	import org.eclipse.emf.ecore.EClass;	24	import org.eclipse.emf.ecore.EClass;
Lines 25-31 Link Here
25	import org.eclipse.emf.ecore.impl.EObjectImpl;	27	import org.eclipse.emf.ecore.impl.EObjectImpl;
26	import org.eclipse.hyades.edit.datapool.IDatapoolRecord;	28	import org.eclipse.hyades.edit.datapool.IDatapoolRecord;
27	import org.eclipse.hyades.edit.datapool.IDatapoolVariable;	29	import org.eclipse.hyades.edit.datapool.IDatapoolVariable;
28	import org.eclipse.hyades.execution.runtime.datapool.DatapoolException;
29	import org.eclipse.hyades.execution.runtime.datapool.IDatapoolEvaluatorExt;	30	import org.eclipse.hyades.execution.runtime.datapool.IDatapoolEvaluatorExt;
30	import org.eclipse.hyades.models.common.datapool.Common_DatapoolPackage;	31	import org.eclipse.hyades.models.common.datapool.Common_DatapoolPackage;
31	import org.eclipse.hyades.models.common.datapool.DPLCell;	32	import org.eclipse.hyades.models.common.datapool.DPLCell;
Lines 33-40 Link Here
33	import org.eclipse.hyades.models.common.datapool.util.DPLPasswordCollection;	34	import org.eclipse.hyades.models.common.datapool.util.DPLPasswordCollection;
34	import org.eclipse.hyades.models.common.util.DatapoolUtil;	35	import org.eclipse.hyades.models.common.util.DatapoolUtil;
35	import org.eclipse.hyades.models.common.util.EncryptionManager;	36	import org.eclipse.hyades.models.common.util.EncryptionManager;
36	import org.eclipse.hyades.models.common.util.XMLParserUtil;
37	import org.w3c.dom.Document;
38		37
39	/**	38	/**
40	* <!-- begin-user-doc -->	39	* <!-- begin-user-doc -->
Lines 301-358 Link Here
301	return (org.eclipse.hyades.execution.runtime.datapool.IDatapoolRecord)this.eContainer();	300	return (org.eclipse.hyades.execution.runtime.datapool.IDatapoolRecord)this.eContainer();
302	}	301	}
303		302
304	private static final String XML_AMPERSAND = "&"; //$NON-NLS-1$
305	private static final String AMPERSAND = "&"; //$NON-NLS-1$
306
307	/**	303	/**
308	* The value associated with the cell is returned.	304	* <p>Pre-compiled pattern for matching the open/close tag names and enclosed
		305	* character data of an XML fragment. For example:</p>
		306	*
		307	* <p><code><[white space]OPEN_TAG_NAME[white space]>CHARACTER_DATA</[white space]CLOSE_TAG_NAME[white space]></code></p>
309	*	308	*
310	* @return The value associated with the cell is returned.	309	* <p>The open tag name is in the first group, the character data is in the second group, and
		310	* the close tag name is in the third group.</p>
		311	*
		312	* <p>Note, the input string is assumed to be trimmed.</p>
311	*/	313	*/
312	public Object getCellValue()	314	private static final Pattern XML_FRAGMENT_PATTERN = Pattern.compile("<\\s(\\w+)\\s>(.)</\\s(\\w+)\\s*>"); //$NON-NLS-1$
313	{	315	private static final String START_LITERAL = "<Literal>"; //$NON-NLS-1$
314	if (this.getValue() == null)	316	private static final String END_LITERAL = "</Literal>"; //$NON-NLS-1$
315	return null;
316
317	String internalValue;
318		317
319	internalValue = this.getValue().trim();	318	/**
		319	* The value associated with the cell is returned.
		320	*
		321	* @return The value associated with the cell is returned.
		322	*/
		323	public Object getCellValue(){
320		324
321	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=117932	325	String cellValue = getValue();
322	// performance optimization. Try unwrapping the <Literal> tags first for literal cell values to avoid xml parsing
323	// All cell values are treated literal when no evaluator is present.
324	if(internalValue.startsWith(START_LITERAL) && internalValue.endsWith(END_LITERAL))
325	{
326	return decryptValue(internalValue.substring(START_LITERAL.length(), (internalValue.length() - END_LITERAL.length())));
327	}
328
329	internalValue = internalValue.replaceAll(AMPERSAND, XML_AMPERSAND);
330	String tag = null, val = null;
331		326
332	//get the tag and value from the XML fragment	327	if(cellValue == null){
333	try {	328	return null;
334	Document doc = XMLParserUtil.parse(internalValue);
335	tag = doc.getFirstChild().getNodeName();
336	DPLLogImpl.log("Tag: " + tag); //$NON-NLS-1$
337	val = doc.getFirstChild().getFirstChild().getNodeValue();
338	DPLLogImpl.log("Val: " + val); //$NON-NLS-1$
339	}
340	catch (Throwable t) {
341	DPLLogImpl.log(t.getMessage());
342	}
343
344	//try to find extension for evaluating tag
345	try
346	{
347	IDatapoolEvaluatorExt evaluator = DatapoolUtil.findDatapoolEvaluator(tag);
348	if(evaluator != null)
349	return decryptValue(evaluator.evaluate(val));
350	}	329	}
351	catch (Exception e) {	330
352	DPLLogImpl.log(e.getMessage());	331	String trimmedCellValue = cellValue.trim();
		332
		333	//Performance optimization to determine if an XML fragment cell value (e.g. <[tag]>[value]</[tag]>):
		334	if(trimmedCellValue.startsWith("<")) {
		335
		336	//Performance optimization for unwrapping literal cell values (e.g. <Literal>[value]</Literal>):
		337	if((trimmedCellValue.startsWith(START_LITERAL)) && (trimmedCellValue.endsWith(END_LITERAL))){
		338	return (decryptValue(trimmedCellValue.substring((START_LITERAL.length()), (trimmedCellValue.length() - END_LITERAL.length()))));
		339	}
		340
		341	try {
		342
		343	//Parse the cell value:
		344	Matcher matcher = XML_FRAGMENT_PATTERN.matcher(trimmedCellValue);
		345
		346	//Determine if an XML fragment cell value:
		347	if(matcher.matches()){
		348
		349	//Resolve the datapool evaluator for the XML tag:
		350	IDatapoolEvaluatorExt evaluator = DatapoolUtil.findDatapoolEvaluator(matcher.group(1));
		351
		352	//Determine if the datapool evaluator exists for the XML tag:
		353	if(evaluator != null){
		354	return (decryptValue(evaluator.evaluate(matcher.group(2))));
		355	}
		356	}
		357	}
		358	catch (Throwable t) {
		359	//Ignore since an invalid/unsupported tag.
		360	}
353	}	361	}
354		362
355	return decryptValue(this.getValue());	363	return (decryptValue(cellValue));
356	}	364	}
357		365
358	/**	366	/**
Lines 491-552 Link Here
491	/**	499	/**
492	* Replace the value associated with the cell.	500	* Replace the value associated with the cell.
493	*	501	*
494	* @param value The value to be associated with this cell.	502	* @param value The value to be associated with this cell.
495	*
496	* @see #getCellValue()	503	* @see #getCellValue()
497	*/	504	*/
498	public void setCellValue(Object value)	505	public void setCellValue(Object cellObject){
499	{	506
500	if(value == null)	507	if(cellObject == null){
501	{	508	setValue("");
502	this.setValue("");
503	return;
504	}	509	}
		510	else{
		511
		512	String cellValue = cellObject.toString();
		513	String trimmedCellValue = cellValue.trim();
505		514
506	String tag = null, val = null;	515	//Performance optimization to determine if an XML fragment cell value (e.g. <[tag]>[value]</[tag]>):
507		516	if(trimmedCellValue.startsWith("<")) {
508	if(value.toString().indexOf("<") != -1) //$NON-NLS-1$	517
509	{	518	try {
510	//get the tag and value from the XML fragment	519
511	try {	520	//Parse the cell value:
512	Document doc = XMLParserUtil.parse(value.toString());	521	Matcher matcher = XML_FRAGMENT_PATTERN.matcher(trimmedCellValue);
513	tag = doc.getFirstChild().getNodeName();	522
514	val = doc.getFirstChild().getFirstChild().getNodeValue();	523	//Determine if an XML fragment cell value and a datapool evaluator exists for the tag:
515	}	524	if((matcher.matches()) && (DatapoolUtil.findDatapoolEvaluator(matcher.group(1)) != null)){
516	catch (Throwable t)	525
517	{	526	setValue(cellValue);
518	}	527
		528	return;
		529	}
		530	}
		531	catch (Throwable t) {
		532	//Ignore since an invalid/unsupported tag.
		533	}
		534	}
		535
		536	if((trimmedCellValue.startsWith(START_LITERAL)) && (trimmedCellValue.endsWith(END_LITERAL))){
		537	setValue(cellValue);
		538	}
		539	else{
		540	setValue(wrapAsLiteral(cellValue));
		541	}
519	}	542	}
520
521	//try to find extension for evaluating tag
522	try
523	{
524	if(tag != null && val != null)
525	{
526	IDatapoolEvaluatorExt evaluator = DatapoolUtil.findDatapoolEvaluator(tag);
527	if(evaluator != null)
528	{
529	this.setValue(value.toString());
530	return;
531	}
532	}
533
534	//no extension point found which would match tag - throw exception
535	throw new DatapoolException(Messages.getString("DPLCellImpl.18") + tag); //$NON-NLS-1$
536	}
537	catch (Throwable t)
538	{
539	String stringValue = value.toString();
540	int index = stringValue.indexOf(START_LITERAL);
541	if(index == -1)
542	{
543	String wrappedValue = wrapAsLiteral(value.toString());
544	this.setValue(wrappedValue);
545	return;
546	}
547	this.setValue(stringValue);
548	return;
549	}
550	}	543	}
551		544
552	/**	545	/**
Lines 559-568 Link Here
559	return this.getCellValue();	552	return this.getCellValue();
560	}	553	}
561		554
562
563	private static final String START_LITERAL = "<Literal>"; //$NON-NLS-1$
564	private static final String END_LITERAL = "</Literal>"; //$NON-NLS-1$
565
566	/*	555	/*
567	* Wraps the text in tags that indicate the text is a literal. All cell	556	* Wraps the text in tags that indicate the text is a literal. All cell
568	* values in this release are literals. Returns the wrapped string.	557	* values in this release are literals. Returns the wrapped string.

Return to bug 249588

Lines 46-52 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/wizard/DatapoolImportWizard.java (-121 / +108 lines)
46	*	46	*
47	* @author Bianca Xue Jiang	47	* @author Bianca Xue Jiang
48	* @author Paul E. Slauenwhite	48	* @author Paul E. Slauenwhite
49	* @version October 31, 2008	49	* @version November 11, 2008
50	* @since March 18, 2005	50	* @since March 18, 2005
51	*/	51	*/
52	public class DatapoolImportWizard extends Wizard implements IImportWizard {	52	public class DatapoolImportWizard extends Wizard implements IImportWizard {
Lines 110-237 Link Here
110	*/	110	*/
111	public boolean performFinish() {	111	public boolean performFinish() {
112		112
113	IRunnableWithProgress operation = new WorkspaceModifyOperation() {	113	IRunnableWithProgress operation = new WorkspaceModifyOperation() {
114		114
115	public void execute(IProgressMonitor monitor) throws InvocationTargetException {	115	public void execute(IProgressMonitor monitor) throws InvocationTargetException {
116		116
117	monitor.beginTask(UiPluginResourceBundle.DatapoolImportWizard_progressMonitor, 4);	117	monitor.beginTask(UiPluginResourceBundle.DatapoolImportWizard_progressMonitor, 4);
118		118
119	try {	119	//Resolve the selected datapool:
120		120	IDatapool datapool = datapoolImportPageTwo.getSelectedDatapool();
121	IDatapool datapool = datapoolImportPageTwo.getSelectedDatapool();	121	boolean isEncrypted = datapoolImportPageTwo.isSelectedDatapoolEncrypted();
122		122	String password = datapoolImportPageTwo.getEncryptedDatapoolPassword();
123	monitor.worked(1);	123
124		124	try {
125	if(datapool == null){	125
126		126	monitor.worked(1);
127	//Assumption: The file name will include the file extension (see org.eclipse.tptp.platform.common.ui.wizard.LocationPage.getFileName()).	127
128	String datapoolFileName = locationPage.getFileName();	128	if(datapool != null){
129		129
130	datapool = ((DPLDatapool)(DatapoolUtil.createNewDatapool(datapoolFileName.substring(0, datapoolFileName.indexOf('.')), null)));	130	if(isEncrypted){
131		131	DatapoolEncryptManager.decryptDatapool(datapool, password);
132	Resource datapoolResource = EMFUtil.getResourceFactory(locationPage.getFileExtension()).createResource(URI.createPlatformResourceURI(locationPage.getContainerFullPath().append(datapoolFileName).toOSString(), false));	132	}
133	datapoolResource.getContents().add(datapool);	133
134	}	134	//Empty the datapool if it contains only an empty default cell:
135		135	if(CSVImportExportUtil.getInstance().isDefaultEmptyDatapool(datapool)){
136	//If the existing datapool only contains only an empty default cell, empty the datapool:	136
137	else if(CSVImportExportUtil.getInstance().isDefaultEmptyDatapool(datapool)){	137	datapool.removeVariable(0);
138		138	datapool.removeEquivalenceClass(0);
139	datapool.removeVariable(0);	139	}
140	datapool.removeEquivalenceClass(0);	140	}
141	}	141	else {
142		142
143	String key = datapoolImportPageTwo.getEncryptedDatapoolPasswordText().getText();	143	//Assumption: The file name will include the file extension (see org.eclipse.tptp.platform.common.ui.wizard.LocationPage.getFileName()).
144		144	String datapoolFileName = locationPage.getFileName();
145	if(datapoolImportPageTwo.isEncrypted()){	145
146	if(!DatapoolEncryptManager.isKeyCorrect(datapool, key)){	146	//Create a new datapool:
147	datapoolImportPageTwo.setMessage(UiPluginResourceBundle.DatapoolExportWizard_wrongpass,3);	147	datapool = ((DPLDatapool)(DatapoolUtil.createNewDatapool(datapoolFileName.substring(0, datapoolFileName.indexOf('.')), null)));
148	datapoolImportPageTwo.getEncryptedDatapoolPasswordText().setText("");	148
149	datapoolImportPageTwo.getEncryptedDatapoolPasswordText().setFocus();	149	//Create the resource and add the datapool:
150	throw new Exception("Password is not correct!");	150	EMFUtil.getResourceFactory(locationPage.getFileExtension()).createResource(URI.createPlatformResourceURI(locationPage.getContainerFullPath().append(datapoolFileName).toOSString(), false)).getContents().add(datapool);
151	}	151	}
152	}	152
153		153	monitor.worked(1);
154	if( DatapoolEncryptManager.isDatapoolEncrypted(datapool))	154
155	{	155	if(datapool.getVariableCount() == 0){
156	DatapoolEncryptManager.decryptDatapool(datapool, key);	156
157	}	157	//Import the CSV file to the datapool:
158		158	CSVImportExportUtil.getInstance().importCSV(datapool,
159	monitor.worked(1);	159	datapoolImportPage.getCSVFileName(),
160		160	datapoolImportPage.firstRowContainsVariableNameType(),
161	if(datapool.getVariableCount() == 0){	161	datapoolImportPage.firstColumnContainsEquivalenceClassName(),
162		162	datapoolImportPage.getImportEncoding());
163	CSVImportExportUtil.getInstance().importCSV(datapool,	163	}
164	datapoolImportPage.getCSVFileName(),	164	else{
165	datapoolImportPage.firstRowContainsVariableNameType(),	165
166	datapoolImportPage.firstColumnContainsEquivalenceClassName(),	166	//Append the CSV file to the datapool:
167	datapoolImportPage.getImportEncoding());	167	CSVImportExportUtil.getInstance().appendFromCSV(datapool,
168	}	168	datapoolImportPage.getCSVFileName(),
169	else{	169	datapoolImportPage.firstRowContainsVariableNameType(),
170		170	datapoolImportPage.firstColumnContainsEquivalenceClassName(),
171	CSVImportExportUtil.getInstance().appendFromCSV(datapool,	171	datapoolImportPage.getImportEncoding());
172	datapoolImportPage.getCSVFileName(),	172	}
173	datapoolImportPage.firstRowContainsVariableNameType(),	173
174	datapoolImportPage.firstColumnContainsEquivalenceClassName(),	174	monitor.worked(1);
175	datapoolImportPage.getImportEncoding());	175
176	}	176	Resource datapoolResource = ((EObject)(datapool)).eResource();
177		177
178	monitor.worked(1);	178	//Save (or serialize) the datapool resource to the workspace:
179		179	EMFUtil.save(datapoolResource);
180	if( DatapoolEncryptManager.isDatapoolEncrypted(datapool))	180
181	{	181	//Attempt to open the editor:
182	DatapoolEncryptManager.encryptDatapool(datapool, key);	182	TestUIUtilities.openEditor(datapoolResource, TestUIExtension.DATAPOOL_EDITOR_PART_ID);
183	}	183
184		184	monitor.worked(1);
185	Resource datapoolResource = ((EObject)(datapool)).eResource();	185	}
186		186	catch(Exception e){
187	//Save (or serialize) the datapool resource to the workspace:	187
188	EMFUtil.save(datapoolResource);	188	UiPlugin.logError(e);
189		189
190	//Attempt to open the editor:	190	new ErrorDialog(getShell(),
191	TestUIUtilities.openEditor(datapoolResource, TestUIExtension.DATAPOOL_EDITOR_PART_ID);	191	UiPluginResourceBundle.WIZ_DATAPOOL_CSV_ERRDLG_TITLE,
192		192	UiPluginResourceBundle._ERROR_WIZ_DATAPOOL_CSV_ERRDLG_IMPFILE,
193	monitor.worked(1);	193	new Status(IStatus.ERROR,
194	}	194	UiPlugin.PLUGIN_ID,
195	catch(Exception e){	195	IStatus.OK,
196		196	e.toString(),
197	UiPlugin.logError(e);	197	e),
198		198	IStatus.ERROR).open();
199	new ErrorDialog(getShell(),	199	}
200	UiPluginResourceBundle.WIZ_DATAPOOL_CSV_ERRDLG_TITLE,	200	finally{
201	UiPluginResourceBundle._ERROR_WIZ_DATAPOOL_CSV_ERRDLG_IMPFILE,	201
202	new Status(IStatus.ERROR,	202	//Encrypted the datapool if decrypted:
203	UiPlugin.PLUGIN_ID,	203	if(isEncrypted){
204	IStatus.OK,	204	DatapoolEncryptManager.encryptDatapool(datapool, password);
205	e.toString(),	205	}
206	e),	206
207	IStatus.ERROR).open();	207	monitor.done();
208	}
209	finally{
210	monitor.done();
211	}
212	}
213	};
214
215	try {
216	String key = datapoolImportPageTwo.getEncryptedDatapoolPasswordText().getText();
217	IDatapool datapool = datapoolImportPageTwo.getSelectedDatapool();
218	if(datapoolImportPageTwo.isEncrypted()){
219	if(!DatapoolEncryptManager.isKeyCorrect(datapool, key)){
220	datapoolImportPageTwo.setMessage(UiPluginResourceBundle.DatapoolExportWizard_wrongpass,3);
221	datapoolImportPageTwo.getEncryptedDatapoolPasswordText().setText("");
222	datapoolImportPageTwo.getEncryptedDatapoolPasswordText().setFocus();
223	return false;
224	}	208	}
225	}	209	}
226	getContainer().run(false, false, operation);	210	};
227	}	211
228	catch (InvocationTargetException e) {	212	try {
229	UiPlugin.logError(e);	213	getContainer().run(false, false, operation);
230	}	214	}
231	catch (InterruptedException e) {	215	catch (InvocationTargetException e) {
232	//Ignore since the operation cannot be cancelled.	216	UiPlugin.logError(e);
233	}	217	}
234		218	catch (InterruptedException e) {
		219	//Ignore since the operation cannot be canceled.
		220	}
		221
235	return true;	222	return true;
236	}	223	}
237	}	224	}

Lines 38-44 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/wizard/DatapoolSelectionPage.java (-34 / +38 lines)
38	*	38	*
39	*	39	*
40	* @author Paul E. Slauenwhite	40	* @author Paul E. Slauenwhite
41	* @version October 31, 2008	41	* @version November 11, 2008
42	* @since October 31, 2008	42	* @since October 31, 2008
43	*/	43	*/
44	public class DatapoolSelectionPage extends WizardPage {	44	public class DatapoolSelectionPage extends WizardPage {
Lines 48-54 Link Here
48	private Text encryptedDatapoolPasswordText = null;	48	private Text encryptedDatapoolPasswordText = null;
49	private IStructuredSelection selection = null;	49	private IStructuredSelection selection = null;
50	private IDatapool selectedDatapool = null;	50	private IDatapool selectedDatapool = null;
51	private boolean isEncrypted = false;	51	private boolean isSelectedDatapoolEncrypted = false;
52		52
53	public DatapoolSelectionPage(String name){	53	public DatapoolSelectionPage(String name){
54	this(name, null);	54	this(name, null);
Lines 80-86 Link Here
80	super.setSelection();	80	super.setSelection();
81		81
82	selectedDatapool = null;	82	selectedDatapool = null;
83	isEncrypted = false;	83	isSelectedDatapoolEncrypted = false;
84		84
85	IProxyNode[] selectedProxyNodes = datapoolSelectionViewer.getSelectedProxyNodes();	85	IProxyNode[] selectedProxyNodes = datapoolSelectionViewer.getSelectedProxyNodes();
86		86
Lines 93-104 Link Here
93	selectedDatapool = ((IDatapool)(eObject));	93	selectedDatapool = ((IDatapool)(eObject));
94		94
95	//Determine if the selected datapool is encrypted:	95	//Determine if the selected datapool is encrypted:
96	isEncrypted = DatapoolEncryptManager.isDatapoolEncrypted(selectedDatapool);	96	isSelectedDatapoolEncrypted = DatapoolEncryptManager.isDatapoolEncrypted(selectedDatapool);
97		97
98	//Show or hide the encrypted datapool password group:	98	if((isSelectedDatapoolEncrypted) && (!encryptedDatapoolPasswordGroup.isVisible())){
99	encryptedDatapoolPasswordGroup.setVisible(isEncrypted);
100
101	if(isEncrypted){
102		99
103	//Set the title of the encrypted datapool password group:	100	//Set the title of the encrypted datapool password group:
104	encryptedDatapoolPasswordGroup.setText(NLS.bind(UiPluginResourceBundle.DatapoolExportWizard_password, selectedDatapool.getName()));	101	encryptedDatapoolPasswordGroup.setText(NLS.bind(UiPluginResourceBundle.DatapoolExportWizard_password, selectedDatapool.getName()));
Lines 107-112 Link Here
107	encryptedDatapoolPasswordText.setText("");	104	encryptedDatapoolPasswordText.setText("");
108	encryptedDatapoolPasswordText.setFocus();	105	encryptedDatapoolPasswordText.setFocus();
109	}	106	}
		107
		108	//Show or hide the encrypted datapool password group:
		109	encryptedDatapoolPasswordGroup.setVisible(isSelectedDatapoolEncrypted);
110	}	110	}
111	}	111	}
112		112
Lines 127-145 Link Here
127	encryptedDatapoolPasswordText.addModifyListener(new ModifyListener(){	127	encryptedDatapoolPasswordText.addModifyListener(new ModifyListener(){
128		128
129	public void modifyText(ModifyEvent e){	129	public void modifyText(ModifyEvent e){
130		130	setPageComplete(validatePage());
131	if(encryptedDatapoolPasswordText.getText().trim().length() > 0){
132
133	setErrorMessage(null);
134
135	setPageComplete(true);
136	}
137	else {
138
139	setErrorMessage(NLS.bind(UiPluginResourceBundle.DatapoolExportWizard_encrypted, selectedDatapool.getName()));
140
141	setPageComplete(false);
142	}
143	}	131	}
144	});	132	});
145		133
Lines 153-167 Link Here
153	public IDatapool getSelectedDatapool(){	141	public IDatapool getSelectedDatapool(){
154	return selectedDatapool;	142	return selectedDatapool;
155	}	143	}
156
157	public Text getEncryptedDatapoolPasswordText(){
158	return encryptedDatapoolPasswordText;
159	}
160		144
161	public boolean isEncrypted(){	145	public boolean isSelectedDatapoolEncrypted(){
162	return isEncrypted;	146	return isSelectedDatapoolEncrypted;
163	}	147	}
164		148
		149	public String getEncryptedDatapoolPassword(){
		150	return (encryptedDatapoolPasswordText.getText().trim());
		151	}
		152
165	protected boolean validatePage() {	153	protected boolean validatePage() {
166		154
167	//Note: The error message is not initially reset to reduce flicker when setting the same error message.	155	//Note: The error message is not initially reset to reduce flicker when setting the same error message.
Lines 171-191 Link Here
171	if(selectedDatapool != null){	159	if(selectedDatapool != null){
172		160
173	//Validate the selected encrypted datapool and its password:	161	//Validate the selected encrypted datapool and its password:
174	if((isEncrypted) && (encryptedDatapoolPasswordText.getText().trim().length() == 0)){	162	if(isSelectedDatapoolEncrypted){
		163
		164	String password = getEncryptedDatapoolPassword();
		165
		166	if(password.length() == 0){
		167
		168	setErrorMessage(NLS.bind(UiPluginResourceBundle.DatapoolExportWizard_encrypted, selectedDatapool.getName()));
		169
		170	//Set focus to the encrypted datapool password:
		171	encryptedDatapoolPasswordText.setFocus();
		172	}
		173	else if(!DatapoolEncryptManager.isKeyCorrect(selectedDatapool, password)){
175		174
176	setErrorMessage(NLS.bind(UiPluginResourceBundle.DatapoolExportWizard_encrypted, selectedDatapool.getName()));	175	setErrorMessage(UiPluginResourceBundle.DatapoolExportWizard_wrongpass);
177		176
178	//Set focus to the encrypted datapool password:	177	//Set focus to the encrypted datapool password:
179	encryptedDatapoolPasswordText.setFocus();	178	encryptedDatapoolPasswordText.setFocus();
		179	}
		180	else{
		181	isValid = true;
		182	}
180	}	183	}
181	else{	184	else{
182
183	isValid = true;	185	isValid = true;
184
185	setErrorMessage(null);
186	}	186	}
187	}	187	}
188		188
		189	if(isValid){
		190	setErrorMessage(null);
		191	}
		192
189	return isValid;	193	return isValid;
190	}	194	}
191	}	195	}

Lines 27-32 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/wizard/DatapoolCSVImportPage.java (-20 / +33 lines)
27	import org.eclipse.swt.events.ModifyListener;	27	import org.eclipse.swt.events.ModifyListener;
28	import org.eclipse.swt.events.SelectionEvent;	28	import org.eclipse.swt.events.SelectionEvent;
29	import org.eclipse.swt.events.SelectionListener;	29	import org.eclipse.swt.events.SelectionListener;
		30	import org.eclipse.swt.graphics.Cursor;
30	import org.eclipse.swt.layout.GridData;	31	import org.eclipse.swt.layout.GridData;
31	import org.eclipse.swt.layout.GridLayout;	32	import org.eclipse.swt.layout.GridLayout;
32	import org.eclipse.swt.widgets.Button;	33	import org.eclipse.swt.widgets.Button;
Lines 35-40 Link Here
35	import org.eclipse.swt.widgets.FileDialog;	36	import org.eclipse.swt.widgets.FileDialog;
36	import org.eclipse.swt.widgets.Group;	37	import org.eclipse.swt.widgets.Group;
37	import org.eclipse.swt.widgets.Label;	38	import org.eclipse.swt.widgets.Label;
		39	import org.eclipse.swt.widgets.Shell;
38	import org.eclipse.swt.widgets.Text;	40	import org.eclipse.swt.widgets.Text;
39		41
40	/**	42	/**
Lines 43-49 Link Here
43	*	45	*
44	* @author Peter Sun	46	* @author Peter Sun
45	* @author Paul E. Slauenwhite	47	* @author Paul E. Slauenwhite
46	* @version March 4, 2008	48	* @version November 11, 2008
47	* @since February 1, 2005	49	* @since February 1, 2005
48	*/	50	*/
49	public class DatapoolCSVImportPage extends WizardPage implements ModifyListener, SelectionListener {	51	public class DatapoolCSVImportPage extends WizardPage implements ModifyListener, SelectionListener {
Lines 286-311 Link Here
286	return;	288	return;
287	}	289	}
288		290
289	protected boolean validateSelection()	291	protected void validateSelection(){
290	{	292
291	setErrorMessage(null);	293	//Note: The error message is not initially reset to reduce flicker when setting the same error message.
292	boolean isCSVValid = true;	294	boolean isValid = false;
293	String path = csvFileText.getText().trim();	295	String csvFileName = getCSVFileName();
294	try	296
295	{	297	if((csvFileName != null) && (csvFileName.trim().length() > 0)){
296	if (path.length() > 0) { //- Bugzilla 109208	298
297	isCSVValid = CSVImportExportUtil.getInstance().validateCSVFile(path, firstRowContainsVariableNameType(), firstColumnContainsEquivalenceClassName(),	299	Shell shell = getShell();
298	getImportEncoding());	300
299	}	301	//Set the wait cursor:
300	}	302	shell.setCursor(new Cursor(shell.getDisplay(), SWT.CURSOR_WAIT));
301	catch(Exception e)	303
302	{	304	try{
303	isCSVValid = false;	305	isValid = CSVImportExportUtil.getInstance().validateCSVFile(csvFileName, firstRowContainsVariableNameType(), firstColumnContainsEquivalenceClassName(), getImportEncoding());
304	setErrorMessage(e.getMessage());	306	}
		307	catch(Exception e){
		308	setErrorMessage(e.getMessage());
		309	}
		310	finally{
		311
		312	//Set the default cursor:
		313	shell.setCursor(null);
		314	}
		315
		316	if(isValid){
		317	setErrorMessage(null);
		318	}
305	}	319	}
306		320
307	setPageComplete(isCSVValid);	321	setPageComplete(isValid);
308	getContainer().updateButtons();	322	getContainer().updateButtons();
309	return isCSVValid;
310	}	323	}
311	}	324	}

Lines 11-17 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/wizard/DatapoolImportPage.java (-26 / +1 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.hyades.test.ui.internal.wizard;	12	package org.eclipse.hyades.test.ui.internal.wizard;
13		13
14	import org.eclipse.hyades.test.ui.datapool.internal.util.CSVImportExportUtil;
15	import org.eclipse.swt.widgets.Composite;	14	import org.eclipse.swt.widgets.Composite;
16		15
17	/**	16	/**
Lines 19-25 Link Here
19	*	18	*
20	* @author Bianca Xue Jiang	19	* @author Bianca Xue Jiang
21	* @author Paul E. Slauenwhite	20	* @author Paul E. Slauenwhite
22	* @version March 4, 2008	21	* @version November 11, 2008
23	* @since March 23, 2005	22	* @since March 23, 2005
24	*/	23	*/
25	public class DatapoolImportPage extends DatapoolCSVImportPage {	24	public class DatapoolImportPage extends DatapoolCSVImportPage {
Lines 42-69 Link Here
42	setControl(parentComposite);	41	setControl(parentComposite);
43	validateSelection();	42	validateSelection();
44	}	43	}
45
46	protected boolean validateSelection()
47	{
48	boolean valid = false;
49	setMessage(null);
50	setErrorMessage(null);
51
52	String csvFile = getCSVFileName();
53
54	try{
55	if((csvFile != null) && (csvFile.length() > 0)){
56	valid = CSVImportExportUtil.getInstance().validateCSVFile(csvFile, firstRowContainsVariableNameType(), firstColumnContainsEquivalenceClassName(), getImportEncoding());
57	}
58	}
59	catch(Exception e){
60	valid = false;
61	setErrorMessage(e.getMessage());
62	}
63
64	setPageComplete(valid);
65	getContainer().updateButtons();
66
67	return valid;
68	}
69	}	44	}

Lines 19-36 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/wizard/DatapoolImportPageTwo.java (-1 / +13 lines)
19	import org.eclipse.swt.SWT;	19	import org.eclipse.swt.SWT;
20	import org.eclipse.swt.events.SelectionAdapter;	20	import org.eclipse.swt.events.SelectionAdapter;
21	import org.eclipse.swt.events.SelectionEvent;	21	import org.eclipse.swt.events.SelectionEvent;
		22	import org.eclipse.swt.graphics.Cursor;
22	import org.eclipse.swt.layout.GridData;	23	import org.eclipse.swt.layout.GridData;
23	import org.eclipse.swt.layout.GridLayout;	24	import org.eclipse.swt.layout.GridLayout;
24	import org.eclipse.swt.widgets.Button;	25	import org.eclipse.swt.widgets.Button;
25	import org.eclipse.swt.widgets.Composite;	26	import org.eclipse.swt.widgets.Composite;
26	import org.eclipse.swt.widgets.Group;	27	import org.eclipse.swt.widgets.Group;
		28	import org.eclipse.swt.widgets.Shell;
27		29
28	/**	30	/**
29	* Datapool CSV import page two.	31	* Datapool CSV import page two.
30	*	32	*
31	*	33	*
32	* @author Paul E. Slauenwhite	34	* @author Paul E. Slauenwhite
33	* @version October 31, 2008	35	* @version November 11, 2008
34	* @since October 31, 2008	36	* @since October 31, 2008
35	*/	37	*/
36	public class DatapoolImportPageTwo extends DatapoolSelectionPage {	38	public class DatapoolImportPageTwo extends DatapoolSelectionPage {
Lines 116-121 Link Here
116	//Validate the selected datapool:	118	//Validate the selected datapool:
117	if(selectedDatapool != null){	119	if(selectedDatapool != null){
118		120
		121	Shell shell = getShell();
		122
		123	//Set the wait cursor:
		124	shell.setCursor(new Cursor(shell.getDisplay(), SWT.CURSOR_WAIT));
		125
119	try {	126	try {
120		127
121	DatapoolImportPage datapoolImportPage = ((DatapoolImportWizard)(getWizard())).getDatapoolImportPage();	128	DatapoolImportPage datapoolImportPage = ((DatapoolImportWizard)(getWizard())).getDatapoolImportPage();
Lines 134-139 Link Here
134	catch(Exception e) {	141	catch(Exception e) {
135	setErrorMessage(e.getMessage());	142	setErrorMessage(e.getMessage());
136	}	143	}
		144	finally{
		145
		146	//Set the default cursor:
		147	shell.setCursor(null);
		148	}
137	}	149	}
138	}	150	}
139	}	151	}