/*******************************************************************************
 * Copyright (c) 2005, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.debug.tests.breakpoints;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.debug.core.model.IBreakpoint;
import org.eclipse.debug.internal.ui.breakpoints.provisional.IBreakpointOrganizer;
import org.eclipse.debug.internal.ui.views.breakpoints.BreakpointOrganizerManager;
import org.eclipse.debug.internal.ui.views.breakpoints.WorkingSetCategory;
import org.eclipse.debug.ui.actions.ExportBreakpointsOperation;
import org.eclipse.debug.ui.actions.ImportBreakpointsOperation;
import org.eclipse.jdt.debug.core.IJavaBreakpoint;
import org.eclipse.jdt.debug.testplugin.JavaTestPlugin;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;

/**
 * Tests the import operations of the breakpoint import export feature
 * 
 * @since 3.2
 */
public class ImportBreakpointsTest extends AbstractBreakpointWorkingSetTest {

	/**
	 * Default constructor
	 * @param name the name for the test
	 */
	public ImportBreakpointsTest(String name) {super(name);}

	/**
	 * Tests import operation from a file. 
	 * @throws Exception catch all passed to framework
	 */
	public void testBreakpointImportFile() throws Exception {
		try {
			ArrayList<IJavaBreakpoint> breakpoints = new ArrayList<IJavaBreakpoint>();
			String typeName = "DropTests";
			breakpoints.add(createClassPrepareBreakpoint(typeName));
			breakpoints.add(createLineBreakpoint(32, typeName));
			breakpoints.add(createLineBreakpoint(28, typeName));
			breakpoints.add(createLineBreakpoint(24, typeName));
			breakpoints.add(createExceptionBreakpoint("Exception", true, false));
			breakpoints.add(createMethodBreakpoint(typeName, "method4", "()V", true, false));
			assertEquals("manager does not contain 6 breakpoints for exporting", getBreakpointManager().getBreakpoints().length, 6);
			Path path = new Path("exbkptA.bkpt");
			assertNotNull("Invalid path", path);
			ExportBreakpointsOperation op = new ExportBreakpointsOperation(breakpoints.toArray(new IBreakpoint[breakpoints.size()]), path.toOSString());
			op.run(new NullProgressMonitor());
			removeAllBreakpoints();
			File file = path.toFile();
			assertNotNull(file);
			assertEquals(true, file.exists());
			ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
			op2.run(new NullProgressMonitor());
			assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
			IBreakpoint[] importedBreakpoints = op2.getImportedBreakpoints();
			assertEquals("imported list should contain same breakpoints", 6, importedBreakpoints.length);
			for (int i = 0; i < importedBreakpoints.length; i++) {
				IBreakpoint breakpoint = importedBreakpoints[i];
				assertEquals("Missing imported breakpoint", breakpoint, getBreakpointManager().getBreakpoint(breakpoint.getMarker()));
			}
			file.delete();
		} 
		finally {
			removeAllBreakpoints();
		}	
	}
	
	/**
	 * Tests import operation from a string buffer.
	 *  
	 * @throws Exception catch all passed to framework
	 */
	public void testBreakpointImportBuffer() throws Exception {
		try {
			ArrayList<IJavaBreakpoint> breakpoints = new ArrayList<IJavaBreakpoint>();
			String typeName = "DropTests";
			breakpoints.add(createClassPrepareBreakpoint(typeName));
			breakpoints.add(createLineBreakpoint(32, typeName));
			breakpoints.add(createLineBreakpoint(28, typeName));
			breakpoints.add(createLineBreakpoint(24, typeName));
			breakpoints.add(createExceptionBreakpoint("Exception", true, false));
			breakpoints.add(createMethodBreakpoint(typeName, "method4", "()V", true, false));
			assertEquals("manager does not contain 6 breakpoints for exporting", getBreakpointManager().getBreakpoints().length, 6);
			ExportBreakpointsOperation op = new ExportBreakpointsOperation(breakpoints.toArray(new IBreakpoint[breakpoints.size()]));
			op.run(new NullProgressMonitor());
			StringBuffer buffer = op.getBuffer();
			assertNotNull("Missing buffer", buffer);
			removeAllBreakpoints();
			ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(buffer, true, true);
			op2.run(new NullProgressMonitor());
			assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
		} 
		finally {
			removeAllBreakpoints();
		}	
	}	
	
	/**
	 * tests and overwrote without remove all
	 * @throws Exception catch all to pass back to framework
	 */
	public void testBreakpointImportOverwrite() throws Exception {
		try {
			ArrayList<IJavaBreakpoint> breakpoints = new ArrayList<IJavaBreakpoint>();
			String typeName = "DropTests";
			breakpoints.add(createClassPrepareBreakpoint(typeName));
			breakpoints.add(createLineBreakpoint(32, typeName));
			breakpoints.add(createLineBreakpoint(28, typeName));
			breakpoints.add(createLineBreakpoint(24, typeName));
			breakpoints.add(createExceptionBreakpoint("Exception", true, false));
			breakpoints.add(createMethodBreakpoint(typeName, "method4", "()V", true, false));
			assertEquals("manager does not contain 6 breakpoints for exporting", getBreakpointManager().getBreakpoints().length, 6);
			Path path = new Path("exbkptB.bkpt");
			assertNotNull("Invalid path", path);
			ExportBreakpointsOperation op = new ExportBreakpointsOperation(breakpoints.toArray(new IBreakpoint[breakpoints.size()]), path.toOSString());
			op.run(new NullProgressMonitor());
			File file = path.toFile();
			assertNotNull(file);
			assertEquals(true, file.exists());
			ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
			op2.run(new NullProgressMonitor());
			assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
			file.delete();
		} 
		finally {
			removeAllBreakpoints();
		}
	}
	
	/**
	 * Tests a bad filename passed to the import operation
	 * 
	 * @throws Exception catch all to pass back to framework
	 */
	public void testBreakpointImportBadFilename() throws Exception {
		try {
			ImportBreakpointsOperation op = new ImportBreakpointsOperation("Badpath", true, true);
			try {
				op.run(new NullProgressMonitor());
			} catch (InvocationTargetException e) {
				assertEquals("should be no breakpoints", 0, getBreakpointManager().getBreakpoints().length);
				return;
			}
			assertTrue("Import should have failed with exception", false);
		}
		finally {
			removeAllBreakpoints();
		}
	}
	
	/**
	 * tests importing breakpoints with working sets
	 * 
	 * @throws Exception catch all to be passed back to the framework
	 */
	public void testBreakpointImportWithWorkingsets() throws Exception {
		try {
		//create the working set and add breakpoints to it
			IBreakpointOrganizer bporg = BreakpointOrganizerManager.getDefault().getOrganizer("org.eclipse.debug.ui.breakpointWorkingSetOrganizer");
			IWorkingSetManager wsmanager = getWorkingSetManager();
			String typeName = "DropTests";
			String setName = "ws_name";
			IWorkingSet set = createSet(setName);
			assertNotNull("workingset does not exist", wsmanager.getWorkingSet(setName));
			WorkingSetCategory category = new WorkingSetCategory(set);
			
			bporg.addBreakpoint(createClassPrepareBreakpoint(typeName), category);
			bporg.addBreakpoint(createLineBreakpoint(32, typeName), category);
			bporg.addBreakpoint(createLineBreakpoint(28, typeName), category);
			bporg.addBreakpoint(createLineBreakpoint(24, typeName), category);
			bporg.addBreakpoint(createExceptionBreakpoint("Exception", true, false), category);
			bporg.addBreakpoint(createMethodBreakpoint(typeName, "method4", "()V", true, false), category);
			assertEquals("workingset does not have 6 elements", 6, set.getElements().length);
			assertEquals("manager does not have 6 breakpoints", getBreakpointManager().getBreakpoints().length, 6);
			Path path = new Path("exbkptC.bkpt");
			assertNotNull("Invalid path", path);
			ExportBreakpointsOperation op = new ExportBreakpointsOperation(getBreakpointManager().getBreakpoints(), path.toOSString());
			op.run(new NullProgressMonitor());
		
			//remove bps and working set and do the import
			removeAllBreakpoints();
			set.setElements(new IAdaptable[] {});
			wsmanager.removeWorkingSet(set);
			set = wsmanager.getWorkingSet(setName);
			assertNull("workingset was not removed", set);
			set = null;
			File file = path.toFile();
			assertNotNull(file);
			assertEquals(true, file.exists());
			ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
			op2.run(new NullProgressMonitor());
			set = wsmanager.getWorkingSet(setName);
			assertNotNull("Import did not create working set", set);
			assertEquals("workingset does not contain 6 breakpoints", 6, set.getElements().length);
			assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
			file.delete();
		}
		finally {
			removeAllBreakpoints();
		}
	}
	
	/**
	 * Tests importing breakpoints to resources that do not exist
	 * @throws Exception catch all passed to framework
	 */
	public void testBreakpointImportMissingResources() throws Exception {
		try {
			File file = JavaTestPlugin.getDefault().getFileInPlugin(new Path("testresources/brkpt_missing.bkpt"));
			assertNotNull(file);
			assertEquals(true, file.exists());
			ImportBreakpointsOperation op = new ImportBreakpointsOperation(file.getCanonicalPath(), true, true);
			op.run(new NullProgressMonitor());
			assertEquals("should be no breakpoints imported", 0, getBreakpointManager().getBreakpoints().length);
		} 
		finally {
			removeAllBreakpoints();
		}
	}
	
	/**
	 * tests importing breakpoints with working sets where the breakpoints are restored to 
	 * another working set and removed from the current one
	 * 
	 * @throws Exception catch all to be passed back to the framework
	 */
	public void testImportWithWorkingsets() throws Exception {
		try {
		//create the working set and add breakpoints to it
			IBreakpointOrganizer bporg = BreakpointOrganizerManager.getDefault().getOrganizer("org.eclipse.debug.ui.breakpointWorkingSetOrganizer");
			IWorkingSetManager wsmanager = getWorkingSetManager();
			String typeName = "DropTests";
			String setname1 = "ws1";
			String setname2 = "ws2";
			IWorkingSet set = createSet(setname1);
			assertNotNull("workingset does not exist", wsmanager.getWorkingSet(setname1));
			WorkingSetCategory category = new WorkingSetCategory(set);
			
			bporg.addBreakpoint(createClassPrepareBreakpoint(typeName), category);
			bporg.addBreakpoint(createLineBreakpoint(32, typeName), category);
			bporg.addBreakpoint(createLineBreakpoint(28, typeName), category);
			bporg.addBreakpoint(createLineBreakpoint(24, typeName), category);
			bporg.addBreakpoint(createExceptionBreakpoint("Exception", true, false), category);
			bporg.addBreakpoint(createMethodBreakpoint(typeName, "method4", "()V", true, false), category);
			assertEquals("workingset does not have 6 elements", 6, set.getElements().length);
			assertEquals("manager does not have 6 breakpoints", getBreakpointManager().getBreakpoints().length, 6);
			Path path = new Path("exbkptC.bkpt");
			assertNotNull("Invalid path", path);
			ExportBreakpointsOperation op = new ExportBreakpointsOperation(getBreakpointManager().getBreakpoints(), path.toOSString());
			op.run(new NullProgressMonitor());
		
			//copy items to the alternate working set
			IWorkingSet set2 = createSet(setname2);
			set2.setElements(set.getElements());
			assertNotNull("workingset does not exist", wsmanager.getWorkingSet(setname2));
			
			//remove bps and working set and do the import
			removeAllBreakpoints();
			set.setElements(new IAdaptable[] {});
			wsmanager.removeWorkingSet(set);
			set = wsmanager.getWorkingSet(setname1);
			assertNull("workingset was not removed", set);
			set = null;
			File file = path.toFile();
			assertNotNull(file);
			assertEquals(true, file.exists());
			ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
			op2.run(new NullProgressMonitor());
			set = wsmanager.getWorkingSet(setname1);
			assertNotNull("Import did not create working set", set);
			assertEquals("workingset does not contain 6 breakpoints", 6, set.getElements().length);
			assertEquals("alternate working set should contain no breakpoints", 0, set2.getElements().length);
			assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
			file.delete();
		}
		finally {
			removeAllBreakpoints();
		}
	}
}