| /******************************************************************************* |
| * Copyright (c) 2000, 2003 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Common Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/cpl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ui.tests.util; |
| |
| import junit.framework.Assert; |
| |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.TabFolder; |
| import org.eclipse.ui.internal.WorkbenchPlugin; |
| import org.eclipse.ui.tests.internal.util.VerifyDialog; |
| |
| /** |
| * A <code>DialogCheck</code> is used test a dialog in |
| * various ways. |
| * <p> |
| * For interactive tests use <code>assertDialog</code>. |
| * For automated tests use <code>assert DialogTexts</code>. |
| * </p> |
| */ |
| public class DialogCheck { |
| private DialogCheck() { |
| } |
| |
| private static VerifyDialog _verifyDialog; |
| |
| /** |
| * Asserts that a given dialog is not null and that it passes |
| * certain visual tests. These tests will be verified manually |
| * by the tester using an input dialog. Use this assert method |
| * to verify a dialog's sizing, initial focus, or accessiblity. |
| * To ensure that both the input dialog and the test dialog are |
| * accessible by the tester, the getShell() method should be used |
| * when creating the test dialog. |
| * |
| * Example usage: |
| * <code>Dialog dialog = new AboutDialog( DialogCheck.getShell() ); |
| * DialogCheck.assertDialog(dialog, this);</code> |
| * |
| * @param dialog the test dialog to be verified. |
| * @param assert this is the test case object, assertions will be |
| * executed on this object. |
| */ |
| public static void assertDialog(Dialog dialog, Assert assertion) { |
| Assert.assertNotNull(dialog); |
| if (_verifyDialog.getShell() == null) { |
| //force the creation of the verify dialog |
| getShell(); |
| } |
| if (_verifyDialog.open(dialog) == IDialogConstants.NO_ID) { |
| Assert.assertTrue(_verifyDialog.getFailureText(), false); |
| } |
| } |
| |
| /** |
| * Automated test that checks all the labels and buttons of a dialog |
| * to make sure there is enough room to display all the text. Any |
| * text that wraps is only approximated and is currently not accurate. |
| * |
| * @param dialog the test dialog to be verified. |
| * @param assert this is the test case object, assertions will be |
| * executed on this object. |
| */ |
| public static void assertDialogTexts(Dialog dialog, Assert assertion) { |
| Assert.assertNotNull(dialog); |
| dialog.setBlockOnOpen(false); |
| dialog.open(); |
| Shell shell = dialog.getShell(); |
| verifyCompositeText(shell, assertion); |
| dialog.close(); |
| } |
| |
| /** |
| * This method should be called when creating dialogs to test. This |
| * ensures that the dialog's parent shell will be that of the |
| * verification dialog. |
| * |
| * @return Shell The shell of the verification dialog to be used as |
| * the parent shell of the test dialog. |
| */ |
| public static Shell getShell() { |
| Shell shell = WorkbenchPlugin.getDefault().getWorkbench() |
| .getActiveWorkbenchWindow().getShell(); |
| _verifyDialog = new VerifyDialog(shell); |
| _verifyDialog.create(); |
| return _verifyDialog.getShell(); |
| } |
| |
| /* |
| * Looks at all the child widgets of a given composite and |
| * verifies the text on all labels and widgets. |
| * @param composite The composite to look through |
| * @param assert The object to invoke assertions on. |
| */ |
| private static void verifyCompositeText(Composite composite, |
| Assert assertion) { |
| Control children[] = composite.getChildren(); |
| for (int i = 0; i < children.length; i++) { |
| if (children[i] instanceof TabFolder) { |
| TabFolder folder = (TabFolder) children[i]; |
| int numPages = folder.getItemCount(); |
| for (int j = 0; j < numPages; j++) { |
| folder.setSelection(j); |
| } |
| } |
| try { |
| //verify the text if the child is a button |
| verifyButtonText((Button) children[i], assertion); |
| } catch (ClassCastException exNotButton) { |
| try { |
| //child is not a button, maybe a label |
| verifyLabelText((Label) children[i], assertion); |
| } catch (ClassCastException exNotLabel) { |
| try { |
| //child is not a label, make a recursive call if it is a composite |
| verifyCompositeText((Composite) children[i], assertion); |
| } catch (ClassCastException exNotComposite) { |
| //the child is not a button, label, or composite - ignore it. |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| * Verifies that a given button is large enough to display its text. |
| * @param button The button to verify, |
| * @param assert The object to invoke assertions on. |
| */ |
| private static void verifyButtonText(Button button, Assert assertion) { |
| String widget = button.toString(); |
| Point size = button.getSize(); |
| |
| //compute the size with no line wrapping |
| Point preferred = button.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| //if (size.y/preferred.y) == X, then label spans X lines, so divide |
| //the calculated value of preferred.x by X |
| if (preferred.y * size.y > 0) { |
| preferred.y /= countLines(button.getText()); //check for '\n\' |
| if (size.y / preferred.y > 1) { |
| preferred.x /= (size.y / preferred.y); |
| } |
| } |
| |
| String message = new StringBuffer("Warning: ").append(widget).append( |
| "\n\tActual Width -> ").append(size.x).append( |
| "\n\tRecommended Width -> ").append(preferred.x).toString(); |
| if (preferred.x > size.x) { |
| //close the dialog |
| button.getShell().dispose(); |
| Assert.assertTrue(message.toString(), false); |
| } |
| } |
| |
| /* |
| * Verifies that a given label is large enough to display its text. |
| * @param label The label to verify, |
| * @param assert The object to invoke assertions on. |
| */ |
| private static void verifyLabelText(Label label, Assert assertion) { |
| String widget = label.toString(); |
| Point size = label.getSize(); |
| |
| //compute the size with no line wrapping |
| Point preferred = label.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| //if (size.y/preferred.y) == X, then label spans X lines, so divide |
| //the calculated value of preferred.x by X |
| if (preferred.y * size.y > 0) { |
| preferred.y /= countLines(label.getText()); |
| if (size.y / preferred.y > 1) { |
| preferred.x /= (size.y / preferred.y); |
| } |
| } |
| String message = new StringBuffer("Warning: ").append(widget).append( |
| "\n\tActual Width -> ").append(size.x).append( |
| "\n\tRecommended Width -> ").append(preferred.x).toString(); |
| if (preferred.x > size.x) { |
| //close the dialog |
| label.getShell().dispose(); |
| Assert.assertTrue(message.toString(), false); |
| } |
| } |
| |
| /* |
| * Counts the number of lines in a given String. |
| * For example, if a string contains one (1) newline character, |
| * a value of two (2) would be returned. |
| * @param text The string to look through. |
| * @return int the number of lines in text. |
| */ |
| private static int countLines(String text) { |
| int newLines = 1; |
| for (int i = 0; i < text.length(); i++) { |
| if (text.charAt(i) == '\n') { |
| newLines++; |
| } |
| } |
| return newLines; |
| } |
| } |