com.sun.jdi.event.EventQueue Java Examples

private void eventLoop() throws InterruptedException {
	System.out.println("eventLoop started");
	EventQueue eventQueue = vm.eventQueue();
	boolean isRunning = true;
	while (isRunning) {
		EventSet eventSet = eventQueue.remove();
		boolean mayResume = true;
		for (Event event : eventSet) {
			System.out.println(event);
			if (event instanceof VMDeathEvent
					|| event instanceof VMDisconnectEvent) {
				isRunning = false;
			} else if (event instanceof ExceptionEvent) {
				mayResume = false;
			}
		}
		if (mayResume) eventSet.resume();
	}
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

private void processVMEvents() {
	try {
		// process events
		final EventQueue eventQueue = vm.eventQueue();
		while (true) {
			EventSet eventSet = eventQueue.remove(TimeUnit.SECONDS.toMillis(this.dataCollectionTimeoutInSeconds));
			if (eventSet == null)
				return; // timeout
			for (Event event : eventSet) {
				if (event instanceof VMDeathEvent || event instanceof VMDisconnectEvent) {
					// exit
					DebugJUnitRunner.process.destroy();
					// logger.debug("Exit");
					// System.out.println("VM Event: Exit");
					return;
				} else if (event instanceof ClassPrepareEvent) {
					// logger.debug("ClassPrepareEvent");
					// System.out.println("VM event: ClassPrepareEvent");
					processClassPrepareEvent();
				} else if (event instanceof BreakpointEvent) {
					// logger.debug("VM Event: BreakpointEvent");
					// System.out.println("VM BreakpointEvent");
					processBreakPointEvents((BreakpointEvent) event);
				}
			}
			eventSet.resume();
		} // end while true
	} catch (Exception e) {
		System.err.println("Error processing VMEvents");
		e.printStackTrace();
	} finally {
		DebugJUnitRunner.process.destroy();
	}
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

public VMRemoteTarget createJVM() throws IOException, InterruptedException,
		IncompatibleThreadStateException {
	Process process = startSecondJVM(VMLocalTarget.class);
	sleep(90);
	// connect
	VirtualMachine vm = new VMAcquirer().connect(debugPort);

	ClassPrepareRequest createClassPrepareRequest = vm
			.eventRequestManager().createClassPrepareRequest();
	createClassPrepareRequest.addClassFilter(VMLocalTarget.class.getName());
	createClassPrepareRequest.enable();
	
	vm.resume();

	List<ThreadReference> allThreads = vm.allThreads();
	for (ThreadReference threadReference : allThreads) {
		System.out.println(threadReference+" isSuspended: "+threadReference.isSuspended()+" suspendCount: "+threadReference.suspendCount());
	}

	// process events
	EventQueue eventQueue = vm.eventQueue();
	while (true) {
		EventSet eventSet = eventQueue.remove();
		for (Event event : eventSet) {
			if (event instanceof ClassPrepareEvent) {
				event.request().disable();
				installHaltPoint(vm);
			}
			if (event instanceof VMDeathEvent
					|| event instanceof VMDisconnectEvent) {
				return null;
			}
			if (event instanceof BreakpointEvent) {
				event.request().disable();
				ThreadReference thread = ((BreakpointEvent) event).thread();
				return new VMRemoteTarget(process, vm, thread, debugPort);
			}
		}
		eventSet.resume();
	}
}
 

public EventQueue eventQueue() {
    throwNotReadOnlyException("VirtualMachine.eventQueue()");
    return null;
}
 

public EventQueue eventQueue() {
    throwNotReadOnlyException("VirtualMachine.eventQueue()");
    return null;
}
 

/**
 * Does a single execution step of the concrete state.
 * 
 * @param doStepInto if {@code true} and the current bytecode is an INVOKEX bytecode,
 *        steps into the invoked method; if {@code false} and the current bytecode is 
 *        an INVOKEX bytecode, steps over.
 * @throws GuidanceException 
 */
private void doStep(boolean doStepInto) throws GuidanceException {
    final int stepDepth = doStepInto ? StepRequest.STEP_INTO : StepRequest.STEP_OVER;

    final ThreadReference thread = this.methodEntryEvent.thread();
    final EventRequestManager mgr = this.vm.eventRequestManager();
    final StepRequest sr = mgr.createStepRequest(thread, StepRequest.STEP_MIN, stepDepth);
    sr.enable();

    //if we are at an ILOAD bytecode followed by an XALOAD, 
    //we store the value from the variable because it is used
    //as XALOAD index
    final int currentCodeIndex = getCurrentCodeIndex();
    final byte[] bc = getCurrentBytecode();
    final byte currentOpcode = bc[currentCodeIndex];
    if (currentOpcode == OP_ILOAD || 
        (OP_ILOAD_0 <= currentOpcode && currentOpcode <= OP_ILOAD_3)) {
        final boolean wide = (this.previousCodeIndex >= 0 && bc[this.previousCodeIndex] == OP_WIDE);
        final int nextCodeIndex; 
        if (currentOpcode == OP_ILOAD) {
            nextCodeIndex = currentCodeIndex + (wide ? XLOADSTORE_IMMEDIATE_WIDE_OFFSET : XLOADSTORE_IMMEDIATE_OFFSET);
        } else {
            nextCodeIndex = currentCodeIndex + XLOADSTORE_IMPLICIT_OFFSET;
        }
        final byte opcodeNext = bc[nextCodeIndex];
        if (OP_IALOAD <= opcodeNext && opcodeNext <= OP_SALOAD) {
            //determines the index of the local variable
            final int localVariableIndex;
            if (currentOpcode == OP_ILOAD_0) {
                localVariableIndex = 0;
            } else if (currentOpcode == OP_ILOAD_1) {
                localVariableIndex = 1;
            } else if (currentOpcode == OP_ILOAD_2) {
                localVariableIndex = 2;
            } else if (currentOpcode == OP_ILOAD_3) {
                localVariableIndex = 3;
            } else {
                localVariableIndex = (wide ? byteCat(bc[currentCodeIndex + 1], bc[currentCodeIndex + 2]) : asUnsignedByte(bc[currentCodeIndex + 1]));
            }
            this.xaloadIndex = readLocalVariable(localVariableIndex);
        } else {
            this.xaloadIndex = null;
        }
    } else if (OP_IALOAD <= currentOpcode && currentOpcode <= OP_SALOAD) {
        //does nothing
    } else {
        this.xaloadIndex = null;
    }
    if (isInvoke(currentOpcode) || isReturn(currentOpcode)) {
        //no valid previous code index
        this.previousCodeIndex = -1;
    } else {
        this.previousCodeIndex = currentCodeIndex;
    }
    this.vm.resume();
    final EventQueue queue = this.vm.eventQueue();

    boolean stepFound = false;
    while (!stepFound) {
        try {
            final EventSet eventSet = queue.remove();
            final EventIterator it = eventSet.eventIterator();
            while (!stepFound && it.hasNext()) {
                final Event event = it.nextEvent();

                if (event instanceof StepEvent) {
                    this.currentStepEvent = (StepEvent) event;
                    stepFound = true;
                }
            }
            if (!stepFound) {
                eventSet.resume();
            }
        } catch (InterruptedException | VMDisconnectedException e) {
            throw new GuidanceException(e);
        }
    }

    sr.disable();
}
 

public static void main(String[] args)
    throws IOException, InterruptedException {

  //VirtualMachine vm = launchTarget(sb.toString());
  VirtualMachine vm = launchTarget(CLASS_NAME);

  System.out.println("Vm launched");

  // process events
  EventQueue eventQueue = vm.eventQueue();
  // resume the vm

  Process process = vm.process();


  // Copy target's output and error to our output and error.
  Thread outThread = new StreamRedirectThread("out reader", process.getInputStream());
  Thread errThread = new StreamRedirectThread("error reader", process.getErrorStream());

  errThread.start();
  outThread.start();

  boolean connected = true;
  int watched = 0;
  while (connected) {
    EventSet eventSet = eventQueue.remove();
    for (Event event : eventSet) {
      System.out.println("FieldMonitor-main receives: "+event);
      if (event instanceof VMStartEvent) {
        addClassWatch(vm);
      } else if (event instanceof VMDeathEvent
          || event instanceof VMDisconnectEvent) {
        // exit
        connected = false;
      } else if (event instanceof ClassPrepareEvent) {
        // watch field on loaded class
        System.out.println("ClassPrepareEvent");
        ClassPrepareEvent classPrepEvent = (ClassPrepareEvent) event;
        ReferenceType refType = classPrepEvent
            .referenceType();
        addFieldWatch(vm, refType);
      } else if (event instanceof ModificationWatchpointEvent) {
        watched++;
        System.out.println("sleep for 500 ms");
        Thread.sleep(500);

        ModificationWatchpointEvent modEvent = (ModificationWatchpointEvent) event;
        System.out.println("old="
            + modEvent.valueCurrent());
        System.out.println("new=" + modEvent.valueToBe());
      }
    }
    System.out.println("resume...");
    eventSet.resume();
  }
  // Shutdown begins when event thread terminates
  try {
      errThread.join(); // Make sure output is forwarded
      outThread.join();
  } catch (InterruptedException exc) {
      // we don't interrupt
  }

  if (watched != 11) { // init + 10 modifications in TestPostFieldModification class
      throw new Error("Expected to receive 11 times ModificationWatchpointEvent, but got "+watched);
  }
}
 

EventSet waitEvent() throws InterruptedException {
    EventQueue queue = jvm.eventQueue();
    return queue.remove();
}
 

public EventQueue eventQueue() {
    throwNotReadOnlyException("VirtualMachine.eventQueue()");
    return null;
}
 

public EventQueue eventQueue() {
    throwNotReadOnlyException("VirtualMachine.eventQueue()");
    return null;
}
 

public static void main(String[] args)
    throws IOException, InterruptedException {

  //VirtualMachine vm = launchTarget(sb.toString());
  VirtualMachine vm = launchTarget(CLASS_NAME);

  System.out.println("Vm launched");

  // process events
  EventQueue eventQueue = vm.eventQueue();
  // resume the vm

  Process process = vm.process();


  // Copy target's output and error to our output and error.
  Thread outThread = new StreamRedirectThread("out reader", process.getInputStream());
  Thread errThread = new StreamRedirectThread("error reader", process.getErrorStream());

  errThread.start();
  outThread.start();

  boolean connected = true;
  int watched = 0;
  while (connected) {
    EventSet eventSet = eventQueue.remove();
    for (Event event : eventSet) {
      System.out.println("FieldMonitor-main receives: "+event);
      if (event instanceof VMStartEvent) {
        addClassWatch(vm);
      } else if (event instanceof VMDeathEvent
          || event instanceof VMDisconnectEvent) {
        // exit
        connected = false;
      } else if (event instanceof ClassPrepareEvent) {
        // watch field on loaded class
        System.out.println("ClassPrepareEvent");
        ClassPrepareEvent classPrepEvent = (ClassPrepareEvent) event;
        ReferenceType refType = classPrepEvent
            .referenceType();
        addFieldWatch(vm, refType);
      } else if (event instanceof ModificationWatchpointEvent) {
        watched++;
        System.out.println("sleep for 500 ms");
        Thread.sleep(500);

        ModificationWatchpointEvent modEvent = (ModificationWatchpointEvent) event;
        System.out.println("old="
            + modEvent.valueCurrent());
        System.out.println("new=" + modEvent.valueToBe());
      }
    }
    System.out.println("resume...");
    eventSet.resume();
  }
  // Shutdown begins when event thread terminates
  try {
      errThread.join(); // Make sure output is forwarded
      outThread.join();
  } catch (InterruptedException exc) {
      // we don't interrupt
  }

  if (watched != 11) { // init + 10 modifications in TestPostFieldModification class
      throw new Error("Expected to receive 11 times ModificationWatchpointEvent, but got "+watched);
  }
}
 

public static void main(String[] args)
    throws IOException, InterruptedException {

  //VirtualMachine vm = launchTarget(sb.toString());
  VirtualMachine vm = launchTarget(CLASS_NAME);

  System.out.println("Vm launched");

  // process events
  EventQueue eventQueue = vm.eventQueue();
  // resume the vm

  Process process = vm.process();


  // Copy target's output and error to our output and error.
  Thread outThread = new StreamRedirectThread("out reader", process.getInputStream());
  Thread errThread = new StreamRedirectThread("error reader", process.getErrorStream());

  errThread.start();
  outThread.start();

  boolean connected = true;
  int watched = 0;
  while (connected) {
    EventSet eventSet = eventQueue.remove();
    for (Event event : eventSet) {
      System.out.println("FieldMonitor-main receives: "+event);
      if (event instanceof VMStartEvent) {
        addClassWatch(vm);
      } else if (event instanceof VMDeathEvent
          || event instanceof VMDisconnectEvent) {
        // exit
        connected = false;
      } else if (event instanceof ClassPrepareEvent) {
        // watch field on loaded class
        System.out.println("ClassPrepareEvent");
        ClassPrepareEvent classPrepEvent = (ClassPrepareEvent) event;
        ReferenceType refType = classPrepEvent
            .referenceType();
        addFieldWatch(vm, refType);
      } else if (event instanceof ModificationWatchpointEvent) {
        watched++;
        System.out.println("sleep for 500 ms");
        Thread.sleep(500);

        ModificationWatchpointEvent modEvent = (ModificationWatchpointEvent) event;
        System.out.println("old="
            + modEvent.valueCurrent());
        System.out.println("new=" + modEvent.valueToBe());
      }
    }
    System.out.println("resume...");
    eventSet.resume();
  }
  // Shutdown begins when event thread terminates
  try {
      errThread.join(); // Make sure output is forwarded
      outThread.join();
  } catch (InterruptedException exc) {
      // we don't interrupt
  }

  if (watched != 11) { // init + 10 modifications in TestPostFieldModification class
      throw new Error("Expected to receive 11 times ModificationWatchpointEvent, but got "+watched);
  }
}
 

public EventQueue eventQueue() {
    throwNotReadOnlyException("VirtualMachine.eventQueue()");
    return null;
}
 

public EventQueue eventQueue() {
    throwNotReadOnlyException("VirtualMachine.eventQueue()");
    return null;
}
 

public static void main(String[] args)
    throws IOException, InterruptedException {

  //VirtualMachine vm = launchTarget(sb.toString());
  VirtualMachine vm = launchTarget(CLASS_NAME);

  System.out.println("Vm launched");

  // process events
  EventQueue eventQueue = vm.eventQueue();
  // resume the vm

  Process process = vm.process();


  // Copy target's output and error to our output and error.
  Thread outThread = new StreamRedirectThread("out reader", process.getInputStream());
  Thread errThread = new StreamRedirectThread("error reader", process.getErrorStream());

  errThread.start();
  outThread.start();

  boolean connected = true;
  int watched = 0;
  while (connected) {
    EventSet eventSet = eventQueue.remove();
    for (Event event : eventSet) {
      System.out.println("FieldMonitor-main receives: "+event);
      if (event instanceof VMStartEvent) {
        addClassWatch(vm);
      } else if (event instanceof VMDeathEvent
          || event instanceof VMDisconnectEvent) {
        // exit
        connected = false;
      } else if (event instanceof ClassPrepareEvent) {
        // watch field on loaded class
        System.out.println("ClassPrepareEvent");
        ClassPrepareEvent classPrepEvent = (ClassPrepareEvent) event;
        ReferenceType refType = classPrepEvent
            .referenceType();
        addFieldWatch(vm, refType);
      } else if (event instanceof ModificationWatchpointEvent) {
        watched++;
        System.out.println("sleep for 500 ms");
        Thread.sleep(500);

        ModificationWatchpointEvent modEvent = (ModificationWatchpointEvent) event;
        System.out.println("old="
            + modEvent.valueCurrent());
        System.out.println("new=" + modEvent.valueToBe());
      }
    }
    System.out.println("resume...");
    eventSet.resume();
  }
  // Shutdown begins when event thread terminates
  try {
      errThread.join(); // Make sure output is forwarded
      outThread.join();
  } catch (InterruptedException exc) {
      // we don't interrupt
  }

  if (watched != 11) { // init + 10 modifications in TestPostFieldModification class
      throw new Error("Expected to receive 11 times ModificationWatchpointEvent, but got "+watched);
  }
}
 

public static void main(String[] args)
    throws IOException, InterruptedException {

  //VirtualMachine vm = launchTarget(sb.toString());
  VirtualMachine vm = launchTarget(CLASS_NAME);

  System.out.println("Vm launched");

  // process events
  EventQueue eventQueue = vm.eventQueue();
  // resume the vm

  Process process = vm.process();


  // Copy target's output and error to our output and error.
  Thread outThread = new StreamRedirectThread("out reader", process.getInputStream());
  Thread errThread = new StreamRedirectThread("error reader", process.getErrorStream());

  errThread.start();
  outThread.start();

  boolean connected = true;
  int watched = 0;
  while (connected) {
    EventSet eventSet = eventQueue.remove();
    for (Event event : eventSet) {
      System.out.println("FieldMonitor-main receives: "+event);
      if (event instanceof VMStartEvent) {
        addClassWatch(vm);
      } else if (event instanceof VMDeathEvent
          || event instanceof VMDisconnectEvent) {
        // exit
        connected = false;
      } else if (event instanceof ClassPrepareEvent) {
        // watch field on loaded class
        System.out.println("ClassPrepareEvent");
        ClassPrepareEvent classPrepEvent = (ClassPrepareEvent) event;
        ReferenceType refType = classPrepEvent
            .referenceType();
        addFieldWatch(vm, refType);
      } else if (event instanceof ModificationWatchpointEvent) {
        watched++;
        System.out.println("sleep for 500 ms");
        Thread.sleep(500);

        ModificationWatchpointEvent modEvent = (ModificationWatchpointEvent) event;
        System.out.println("old="
            + modEvent.valueCurrent());
        System.out.println("new=" + modEvent.valueToBe());
      }
    }
    System.out.println("resume...");
    eventSet.resume();
  }
  // Shutdown begins when event thread terminates
  try {
      errThread.join(); // Make sure output is forwarded
      outThread.join();
  } catch (InterruptedException exc) {
      // we don't interrupt
  }

  if (watched != 11) { // init + 10 modifications in TestPostFieldModification class
      throw new Error("Expected to receive 11 times ModificationWatchpointEvent, but got "+watched);
  }
}
 

/**
 * Starts retrieving events from the event queue of the specified virtual machine.
 *
 * @param vm
 *            the target virtual machine.
 */
@Override
public void start(VirtualMachine vm) {
    if (isClosed) {
        throw new IllegalStateException("This event hub is already closed.");
    }

    workingThread = new Thread(() -> {
        EventQueue queue = vm.eventQueue();
        while (true) {
            try {
                if (Thread.interrupted()) {
                    subject.onComplete();
                    return;
                }

                EventSet set = queue.remove();

                boolean shouldResume = true;
                for (Event event : set) {
                    try {
                        logger.fine("\nJDI Event: " + event + "\n");
                    } catch (VMDisconnectedException e) {
                        // do nothing
                    }
                    DebugEvent dbgEvent = new DebugEvent();
                    dbgEvent.event = event;
                    dbgEvent.eventSet = set;
                    subject.onNext(dbgEvent);
                    shouldResume &= dbgEvent.shouldResume;
                }

                if (shouldResume) {
                    set.resume();
                }
            } catch (InterruptedException e) {
                isClosed = true;
                subject.onComplete();
                return;
            } catch (VMDisconnectedException e) {
                isClosed = true;
                subject.onError(e);
                return;
            }
        }
    }, "Event Hub");

    workingThread.start();
}