Java IJavaLineBreakpoint类代码示例

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
private void createJavaBreakpoints(JimpleBreakpoint jimpleBreakpoint) throws CoreException {
	IMarker m = jimpleBreakpoint.getMarker();
	List<BreakpointLocation> breakpointLocations = breakpointLocator.findFlowFunctions();
	for (BreakpointLocation breakpointLocation : breakpointLocations) {
		IJavaLineBreakpoint javaBreakpoint = (IJavaLineBreakpoint) createMethodEntryBreapoint(breakpointLocation);
		IJavaLineBreakpoint javaLineBreakpoint = javaBreakpoint;
		javaLineBreakpoint.setConditionEnabled(true);
		String requiredFqn = m.getAttribute("Jimple.unit.fqn", "");
		String escapedRequiredFqn = requiredFqn.replaceAll("\"", "\\\\\"");
		// FIXME find out the name of the unit
		javaLineBreakpoint.setCondition("new String(d.getTag(\"Fully Qualified Name\").getValue()).equals(\""+escapedRequiredFqn+"\")");
		javaLineBreakpoint.setConditionSuspendOnTrue(true);
		IMarker javaBreakpointMarker = javaBreakpoint.getMarker();
		javaBreakpointMarker.setAttribute("Jimple.breakpoint.type", "unit");
		javaBreakpointMarker.setAttribute("Jimple." + IMarker.LINE_NUMBER, m.getAttribute(IMarker.LINE_NUMBER, -1));
		javaBreakpointMarker.setAttribute("Jimple.unit.charStart", m.getAttribute("Jimple.unit.charStart", -1));
		javaBreakpointMarker.setAttribute("Jimple.unit.charEnd", m.getAttribute("Jimple.unit.charEnd", -1));
		javaBreakpointMarker.setAttribute("Jimple.unit.fqn", requiredFqn);
		javaBreakpointMarker.setAttribute("Jimple.project", m.getAttribute("Jimple.project", ""));
		javaBreakpointMarker.setAttribute("Jimple.file", m.getAttribute("Jimple.file", ""));
		jimpleBreakpoint.addJavaBreakpoint(javaBreakpoint);
		javaBreakpoint.addBreakpointListener(JAVA_BREAKPOINT_LISTENER);
	}
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
public int breakpointHit(IJavaThread thread, IJavaBreakpoint breakpoint) {
	PandionJView pjView = PandionJView.getInstance();
	if(pjView == null)
		return IJavaBreakpointListener.DONT_SUSPEND;

	if(breakpoint instanceof IJavaLineBreakpoint) {
		if(!thread.isPerformingEvaluation()) {
			pjView.handleLinebreakPoint(thread);
			return IJavaBreakpointListener.SUSPEND;
		}
	}
	else if (breakpoint instanceof IJavaExceptionBreakpoint) {
		pjView.handleExceptionBreakpoint(thread, ((IJavaExceptionBreakpoint) breakpoint).getExceptionTypeName());
		return IJavaBreakpointListener.SUSPEND;
	}
	return IJavaBreakpointListener.DONT_SUSPEND;
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
/**
 * Classifies the breakpoint type of the given breakpoint by analyzing its
 * class name.
 * 
 * WARNING: Do not change the ordering of the if-statements if you don't
 * have to!
 */
public static BreakpointType classify(IBreakpoint breakpoint) {
	if (breakpoint instanceof IJavaWatchpoint) {
		return BreakpointType.FIELD;
	} else if (breakpoint instanceof IJavaMethodBreakpoint) {
		return BreakpointType.METHOD;
	} else if (breakpoint instanceof IJavaClassPrepareBreakpoint) {
		return BreakpointType.CLASS;
	} else if (breakpoint instanceof IJavaLineBreakpoint) {
		return BreakpointType.LINE;
	} else if (breakpoint instanceof IJavaExceptionBreakpoint) {
		return BreakpointType.EXCEPTION;
	} else {
		return BreakpointType.UNDEFINED;
	}
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
private void updateBreakpoint(Breakpoint teavmBreakpoint) {
    IJavaLineBreakpoint breakpoint = breakpointBackMap.get(teavmBreakpoint);
    if (breakpoint != null) {
        try {
            if (!teavmBreakpoint.isValid() || !teavmDebugger.isAttached()) {
                breakpoint.getMarker().setAttribute(JAVA_BREAKPOINT_INSTALL_COUNT, 0);
            } else {
                breakpoint.getMarker().setAttribute(JAVA_BREAKPOINT_INSTALL_COUNT, 1);
            }
            DebugPlugin.getDefault().getBreakpointManager().fireBreakpointChanged(breakpoint);
        } catch (CoreException e) {
            throw new RuntimeException(e);
        }
        fireEvent(new DebugEvent(breakpoint, DebugEvent.CHANGE));
    }
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
@Override
public void run() {
	IBreakpoint breakpoint = getBreakpoint();
	if (fBreakpoint != null) {
		AbstractBreakpoint watchPoint = wpMgr.getBreakpoint(breakpoint);			
		if (watchPoint != null) {
			watchPoint.setTrackingActive(!watchPoint.isTrackingActive());
		}
		else if (fBreakpoint instanceof IJavaWatchpoint){
			wpMgr.createWatchpoint((IJavaWatchpoint)fBreakpoint, true);
		}
		else if (fBreakpoint instanceof IJavaLineBreakpoint){
			wpMgr.createBreakpoint((IJavaLineBreakpoint)fBreakpoint, true);
		}
	}
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
@Test
public void testCreateJavaLineBreakpointConditionEnabled() throws CoreException {
	IJavaLineBreakpoint bp = mock(IJavaLineBreakpoint.class);
	when(bp.isConditionEnabled()).thenReturn(true);
	Breakpoint result = BreakpointCreator.createBreakpoint(bp);
	assertTrue(result.isConditionEnabled());
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
@Test
public void testCreateJavaLineBreakpointConditionDisabled() throws CoreException {
	IJavaLineBreakpoint bp = mock(IJavaLineBreakpoint.class);
	when(bp.isConditionEnabled()).thenReturn(false);
	Breakpoint result = BreakpointCreator.createBreakpoint(bp);
	assertFalse(result.isConditionEnabled());
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
@Test
public void testCreateJavaLineBreakpointNoCondition() throws CoreException {
	IJavaLineBreakpoint bp = mock(IJavaLineBreakpoint.class);
	when(bp.getCondition()).thenReturn(null);
	Breakpoint result = BreakpointCreator.createBreakpoint(bp);
	assertNull(result.getCondition());
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
@Test
public void testCreateJavaLineBreakpointCondition() throws CoreException {
	IJavaLineBreakpoint bp = mock(IJavaLineBreakpoint.class);
	when(bp.getCondition()).thenReturn("cond");
	Breakpoint result = BreakpointCreator.createBreakpoint(bp);
	assertEquals("cond", result.getCondition());
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
@Override
public void breakpointAdded(IBreakpoint breakpoint) {
    try {
        IJavaLineBreakpoint lineBreakpoint = (IJavaLineBreakpoint)breakpoint;
        String fileName = lineBreakpoint.getTypeName().replace('.', '/') + ".java";
        Breakpoint teavmBreakpoint = teavmDebugger.createBreakpoint(fileName, lineBreakpoint.getLineNumber());
        breakpointMap.put(lineBreakpoint, teavmBreakpoint);
        breakpointBackMap.put(teavmBreakpoint, lineBreakpoint);
    } catch (CoreException e) {
        throw new RuntimeException(e);
    }
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
@Override
public void breakpointHasRuntimeException(IJavaLineBreakpoint breakpoint, DebugException exception) {
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
@Override
public void breakpointHasCompilationErrors(IJavaLineBreakpoint breakpoint, Message[] errors) {
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
@Override
public boolean supportsBreakpoint(IBreakpoint breakpoint) {
    return breakpoint instanceof IJavaLineBreakpoint;
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
/**
 * 
 * @param javaBreakpoint the underlying {@link IJavaWatchpoint} for this watchpoint
 * @param target the {@link IJavaDebugTarget} this watchpoint has been installed in
 */
public Breakpoint(final IJavaLineBreakpoint javaBreakpoint, boolean trackingActive) {
	super(trackingActive);
	this.javaBreakpoint = javaBreakpoint;
	
}
 

import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; //导入依赖的package包/类
public IJavaLineBreakpoint getBreakpoint() {
	return javaBreakpoint;
}