@Test
  public void testEditMenu() throws Exception {
    MyTablePage page = new MyTablePage();
    page.loadChildren();

    page.getTable().selectFirstRow();
    boolean run = page.getTable().runMenu(EditMenu.class);
    Assert.assertTrue(run);
  }

MyForm form = new MyForm();
form.setMyNr(getMyNrColumn().getSelectedValue());
form.startModify();
form.waitFor();

FileChooser fileChooser = new FileChooser();
fileChooser.setTypeLoad(true);
File[] files = fileChooser.startChooser();

  @Test
  public void testMyButton() throws Exception {
    final File file = new File("some path...");

    DesktopListener listener = new DesktopListener() {
      @Override
      public void desktopChanged(DesktopEvent e) {
        if (e.getType() == DesktopEvent.TYPE_FILE_CHOOSER_ADDED) {
          IFileChooser chooser = e.getFileChooser();
          chooser.setFiles(new File[]{file});
        }
      }
    };
    ClientSession.get().getDesktop().addDesktopListener(listener);

    MyForm form = getForm();
    form.getMyButton().doClick();

    ClientSession.get().getDesktop().removeDesktopListener(listener);
  }

/**
   * If clicking a button leads to a lock because execClickAction contains waitFor() no code can be executed until the
   * lock is released.
   * With this function it is possible to execute code just before the lock is installed.
   * <p>
   * The caller must ensure that the lock gets released (f.e. by canceling the form at the and of the runnable).
   * </p>
   * 
   * @param button
   * @param runnableAfterButtonClick
   * @throws ProcessingException
   */
  public static void clickBlockingButton(IButton button, Runnable runnableAfterButtonClick) throws ProcessingException {
    TestingExceptionHandlerService exceptionHandler = new TestingExceptionHandlerService();
    List<ServiceRegistration> regs = TestingUtility.registerServices(Activator.getDefault().getBundle(), 1000, exceptionHandler);

    WaitForListener waitForListener = new WaitForListener(runnableAfterButtonClick);
    ClientJob currentJob = (ClientJob) ClientJob.getJobManager().currentJob();
    currentJob.addJobChangeListenerEx(waitForListener);
    try {
      //click button which opens the form and blocks with waitFor()
      button.doClick();
      exceptionHandler.assertNoException();
      exceptionHandler.clear();
    }
    finally {
      currentJob.removeJobChangeListenerEx(waitForListener);
      TestingUtility.unregisterServices(regs);
    }

  }

  public static <T extends IForm> T findLastAddedForm(Class<T> formType) {
    T[] forms = ClientSession.get().getDesktop().findForms(formType);
    if (forms == null || forms.length == 0) {
      return null;
    }

    return forms[forms.length - 1];
  }

  private static class WaitForListener extends JobChangeAdapterEx {
    private Runnable runnable;

    public WaitForListener(Runnable runnable) {
      this.runnable = runnable;
    }

    @Override
    public void blockingConditionStart(IJobChangeEvent event) {
      try {
        runnable.run();
      }
      catch (Throwable t) {
        //Exception would be catched by the listener so it is necessary to use the exception service in order to make the test fail.
        SERVICES.getService(TestingExceptionHandlerService.class).handleException(new ProcessingException("", t));
      }
    }

  }

/**
 * Use this custom exception handler service to catch all exceptions (message boxes) and check for specific events
 */
public class TestingExceptionHandlerService extends AbstractService implements IExceptionHandlerService {
  private ProcessingException m_lastException;

  @Override
  public void handleException(ProcessingException t) {
    if (t != null) {
      String message = t.getStatus().getMessage().replaceAll("\\s+", " ").trim();
      System.out.println("consuming: " + message);
    }
    m_lastException = t;
  }

  public void assertNoException() {
    if (m_lastException == null) {
      return;
    }

    if (m_lastException.getCause() instanceof AssertionError) {
      throw (AssertionError) m_lastException.getCause();
    }

    throw new RuntimeException(m_lastException);
  }

  /**
   * similar means all whitespace is replaced by one space and all text is lower case for compare
   */
  public void assertLastExceptionIsSimilarTo(Class<?> type, String message) {
    Assert.assertNotNull(m_lastException);
    Assert.assertEquals(type, m_lastException.getClass());
    String expected = m_lastException.getStatus().getMessage().toLowerCase().replaceAll("\\s+", " ").trim();
    String actual = message.toLowerCase().replaceAll("\\s+", " ").trim();
    Assert.assertEquals(expected, actual);
  }

  public void clear() {
    m_lastException = null;
  }
}