Java WidgetNotFoundException类代码示例

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
public boolean test() throws Exception {
	try {
		
		SWTBotTreeItem item = this.problemView.expandErrorItem ();
		SWTBotTreeItem[] child = item.getItems();
		for (int i = 0; i < child.length; i++) {
			if (child[i].isSelected() && child[i].row().get(0).equalsIgnoreCase(checkedItem.row().get(0))) {
				return true;
			}
		}
		retry ();
		return false;
	} catch (WidgetNotFoundException e) {
		retry ();
		return false;
	}
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
/**
 * Given a tree that contains an entry with <code>itemName</code> and a direct child with a name
 * matching <code>subchildName</code>, return its tree item.
 *
 * This method is useful when there is the possibility of a tree having two similarly-named
 * top-level nodes.
 *
 * @param mainTree the tree
 * @param itemName the name of a top-level node in the tree
 * @param subchildName the name of a direct child of the top-level node (used to uniquely select
 *        the appropriate tree item for the given top-level node name)
 * @return the tree item corresponding to the top-level node with <code>itemName</code>that has a
 *         direct child with <code>subchildName</code>. If there are multiple tree items that
 *         satisfy this criteria, then the first one (in the UI) will be returned
 *
 * @throws WidgetNotFoundException if no such node can be found
 */
public static SWTBotTreeItem getUniqueTreeItem(final SWTBot bot, final SWTBotTree mainTree,
    String itemName, String subchildName) {
  for (SWTBotTreeItem item : mainTree.getAllItems()) {
    if (itemName.equals(item.getText())) {
      try {
        item.expand();
        waitUntilTreeHasText(bot, item);
        if (item.getNode(subchildName) != null) {
          return item;
        }
      } catch (WidgetNotFoundException ex) {
        // Ignore
      }
    }
  }

  throw new WidgetNotFoundException(
      "The " + itemName + " node with a child of " + subchildName + " must exist in the tree.");
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
public static void beforeClass() {
	UIThreadRunnable.syncExec(new VoidResult() {
		public void run() {
			resetWorkbench();
			resetToolbox();
			
			// close browser-based welcome screen (if open)
			SWTWorkbenchBot bot = new SWTWorkbenchBot();
			try {
				SWTBotView welcomeView = bot.viewByTitle("Welcome");
				welcomeView.close();
			} catch (WidgetNotFoundException e) {
				return;
			}
		}
	});
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
/**
 * Given a tree that contains an entry with <code>itemName</code> and a direct child with a name
 * matching <code>subchildName</code>, return its tree item.
 *
 * This method is useful when there is the possibility of a tree having two similarly-named
 * top-level nodes.
 *
 * @param mainTree the tree
 * @param itemName the name of a top-level node in the tree
 * @param subchildName the name of a direct child of the top-level node (used to uniquely select
 *        the appropriate tree item for the given top-level node name)
 * @return the tree item corresponding to the top-level node with <code>itemName</code>that has a
 *         direct child with <code>subchildName</code>. If there are multiple tree items that
 *         satisfy this criteria, then the first one (in the UI) will be returned
 *
 * @throws IllegalStateException if no such node can be found
 */
public static SWTBotTreeItem getUniqueTreeItem(final SWTBot bot, final SWTBotTree mainTree,
    String itemName, String subchildName) {
  for (SWTBotTreeItem item : mainTree.getAllItems()) {
    if (itemName.equals(item.getText())) {
      try {
        item.expand();
        SwtBotTreeActions.waitUntilTreeHasText(bot, item);
        if (item.getNode(subchildName) != null) {
          return item;
        }
      } catch (WidgetNotFoundException e) {
        // Ignore
      }
    }
  }

  throw new IllegalStateException("The '" + itemName + "' node with a child of '" + subchildName
      + "' must exist in the tree.");
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
/**
 * Returns true if the specified project can be found in the 'Package Explorer' or 'Project View',
 * otherwise returns false. Throws a WidgetNotFoundException exception if the 'Package Explorer'
 * or 'Project Explorer' view cannot be found.
 *
 * @param bot The SWTWorkbenchBot.
 * @param projectName The name of the project to be found.
 * @return if the project exists
 */
public static boolean doesProjectExist(final SWTWorkbenchBot bot, String projectName) {
  SWTBotView explorer = getPackageExplorer(bot);
  if (explorer == null) {
    throw new WidgetNotFoundException(
        "Could not find the 'Package Explorer' or 'Project Explorer' view.");
  }

  // Select the root of the project tree in the explorer view
  Widget explorerWidget = explorer.getWidget();
  Tree explorerTree = bot.widget(widgetOfType(Tree.class), explorerWidget);
  SWTBotTreeItem[] allItems = new SWTBotTree(explorerTree).getAllItems();
  for (int i = 0; i < allItems.length; i++) {
    if (allItems[i].getText().equals(projectName)) {
      return true;
    }
  }
  return false;
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
/**
 * Returns the specified project. Throws a WidgetNotFoundException if the 'Package Explorer' or
 * 'Project Explorer' view cannot be found or if the specified project cannot be found.
 *
 * @param bot The SWTWorkbenchBot.
 * @param projectName The name of the project to select.
 * @return the tree
 */
public static SWTBotTreeItem selectProject(final SWTWorkbenchBot bot, String projectName) {
  /*
   * Choose either the Package Explorer View or the Project Explorer view. Eclipse 3.3 and 3.4
   * start with the Java Perspective, which has the Package Explorer View open by default, whereas
   * Eclipse 3.5 starts with the Resource Perspective, which has the Project Explorer View open.
   */
  SWTBotView explorer = getPackageExplorer(bot);
  for (SWTBotView view : bot.views()) {
    if (view.getTitle().equals("Package Explorer")
        || view.getTitle().equals("Project Explorer")) {
      explorer = view;
      break;
    }
  }

  if (explorer == null) {
    throw new WidgetNotFoundException(
        "Could not find the 'Package Explorer' or 'Project Explorer' view.");
  }

  // Select the root of the project tree in the explorer view
  Widget explorerWidget = explorer.getWidget();
  Tree explorerTree = bot.widget(widgetOfType(Tree.class), explorerWidget);
  return new SWTBotTree(explorerTree).getTreeItem(projectName).select();
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
@Before
public void baseBeforeTest() {
	// Sets codenvy fake API
	CodenvyAPI.setClient(new FakeCodenvyClient());
	    	
    UIThreadRunnable.syncExec(new VoidResult() {
        @Override
        public void run() {
            final Shell eclipseShell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
            eclipseShell.forceFocus();
        }
    });

    try {

        final SWTBotView welcomeView = bot.viewByTitle("Welcome");
        welcomeView.close();

    } catch (WidgetNotFoundException e) {
        // ignore the exception
    }
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
@BeforeClass
public static void beforeClass() throws Exception {
	bot = new SWTWorkbenchBot();
	try {
		bot.viewByTitle("Welcome").close();
	} catch (WidgetNotFoundException e) {
		// OK, no Welcome view, that's fine :)
	}

	// Change the perspective via the Open Perspective dialog
	bot.menu("Window").menu("Open Perspective").menu("Other...").click();
	SWTBotShell openPerspectiveShell = bot.shell("Open Perspective");
	openPerspectiveShell.activate();

	// select the dialog
	bot.table().select("Plug-in Development");
	bot.button("OK").click();

	// in Luna the Error Log is not shown by default in the Plug-in Development perspective
	// bot.viewByPartName("Error Log").close();

	// in SwtBot 2.2.0 we must use viewByPartName instead of viewByTitle
	bot.viewByPartName("Problems").show();
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
public boolean test() throws Exception {
	try {
		return fileItem.isSelected() & fileItem.isVisible();
	} catch (WidgetNotFoundException e) {
		return false;
	}
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
protected boolean isProjectCreated(String name) {
	try {
		getProjectTreeItem(name);
		return true;
	} catch (WidgetNotFoundException e) {
		return false;
	}
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
private SWTBotToolbarButton findToolBarButton (String text) {
	List<SWTBotToolbarButton> items = this.botView.getToolbarButtons();
	for (SWTBotToolbarButton button : items) {
	    if (text.equals(button.getToolTipText())) {
	        return button;
	    }
	}
	throw new WidgetNotFoundException (text);
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
@Override
public boolean test() throws Exception {
	try {
		return botTree.contextMenu(mMenuText).isVisible();
	} catch (WidgetNotFoundException e) {
		return false;
	}

}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
public boolean test() throws Exception {
	try {
		return pbView.countErrorWithText(text) == count;
	} catch (WidgetNotFoundException e) {
		 return false;
	}
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
public boolean test() throws Exception {
	try {
		this.problemView.findErrorItemWithText (error);
		return  false;
	} catch (WidgetNotFoundException e) {
		 return true;
	}
}
 

import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException; //导入依赖的package包/类
public boolean test() throws Exception {
	try {
		SWTBotCTabItem tabItem = bot.cTabItem(title);
		return tabItem!=null;
	} catch (WidgetNotFoundException e) {
		 return false;
	}
}