[132] | 1 | package de.ugoe.cs.eventbench.swing;
|
---|
| 2 |
|
---|
| 3 | import java.awt.BorderLayout;
|
---|
[164] | 4 | import java.util.Enumeration;
|
---|
[132] | 5 | import java.util.List;
|
---|
[213] | 6 | import java.util.SortedSet;
|
---|
| 7 | import java.util.TreeSet;
|
---|
[134] | 8 |
|
---|
| 9 | import de.ugoe.cs.eventbench.assertions.AssertEvent;
|
---|
| 10 | import de.ugoe.cs.eventbench.assertions.FileEqualsReplay;
|
---|
| 11 | import de.ugoe.cs.eventbench.assertions.TextEqualsReplay;
|
---|
[132] | 12 | import de.ugoe.cs.eventbench.data.Event;
|
---|
[144] | 13 | import de.ugoe.cs.eventbench.data.GlobalDataContainer;
|
---|
| 14 | import de.ugoe.cs.util.console.Console;
|
---|
[132] | 15 |
|
---|
| 16 | import javax.swing.JButton;
|
---|
| 17 | import javax.swing.JDialog;
|
---|
| 18 | import javax.swing.JPanel;
|
---|
| 19 | import javax.swing.border.EmptyBorder;
|
---|
| 20 | import javax.swing.JComboBox;
|
---|
| 21 | import javax.swing.JLabel;
|
---|
| 22 | import javax.swing.JTextField;
|
---|
| 23 | import javax.swing.JOptionPane;
|
---|
| 24 | import javax.swing.JFileChooser;
|
---|
| 25 | import java.awt.event.MouseAdapter;
|
---|
| 26 | import java.awt.event.MouseEvent;
|
---|
| 27 | import java.io.File;
|
---|
| 28 | import java.awt.event.ActionListener;
|
---|
| 29 | import java.awt.event.ActionEvent;
|
---|
| 30 | import javax.swing.JScrollPane;
|
---|
[155] | 31 | import javax.swing.border.EtchedBorder;
|
---|
| 32 | import javax.swing.JTree;
|
---|
| 33 | import javax.swing.tree.DefaultTreeModel;
|
---|
| 34 | import javax.swing.tree.DefaultMutableTreeNode;
|
---|
[213] | 35 | import javax.swing.tree.TreeNode;
|
---|
[164] | 36 | import javax.swing.tree.TreePath;
|
---|
[213] | 37 | import javax.swing.tree.TreeSelectionModel;
|
---|
[132] | 38 |
|
---|
[213] | 39 | /**
|
---|
| 40 | * <p>
|
---|
| 41 | * This class provides the dialog to insert one of the available assertion
|
---|
| 42 | * types.
|
---|
| 43 | * </p>
|
---|
| 44 | *
|
---|
| 45 | * @author Jeffrey Hall
|
---|
| 46 | * @version 1.0
|
---|
| 47 | */
|
---|
[132] | 48 | public class DlgInsert extends JDialog {
|
---|
[139] | 49 |
|
---|
[134] | 50 | /**
|
---|
| 51 | * Id for object serialization.
|
---|
| 52 | */
|
---|
| 53 | private static final long serialVersionUID = 1L;
|
---|
[132] | 54 |
|
---|
| 55 | private final JPanel contentPanel = new JPanel();
|
---|
| 56 | private JTextField textFieldExpectedValue;
|
---|
[134] | 57 | private JTextField textFieldActualFile;
|
---|
| 58 | private JTextField textFieldExpectedFile;
|
---|
[132] | 59 |
|
---|
| 60 | /**
|
---|
[213] | 61 | * <p>
|
---|
| 62 | * Launch the dialog
|
---|
| 63 | * </p>
|
---|
| 64 | *
|
---|
| 65 | * @param sequences
|
---|
| 66 | * A list of the events where an assertion will be inserted.
|
---|
| 67 | * @param selectedIndex
|
---|
| 68 | * The position for inserting an assertion.
|
---|
| 69 | * @param insertBefore
|
---|
| 70 | * To decide if the user clicked 'insert before' or 'insert
|
---|
| 71 | * after'.
|
---|
[132] | 72 | */
|
---|
[139] | 73 | public static void showDialog(List<Event<?>> sequences, int selectedIndex,
|
---|
| 74 | final boolean insertBefore) {
|
---|
[132] | 75 | try {
|
---|
[139] | 76 | DlgInsert dialog = new DlgInsert(sequences, selectedIndex,
|
---|
| 77 | insertBefore);
|
---|
[132] | 78 | dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
|
---|
| 79 | dialog.setVisible(true);
|
---|
| 80 | } catch (Exception e) {
|
---|
| 81 | e.printStackTrace();
|
---|
| 82 | }
|
---|
| 83 | }
|
---|
| 84 |
|
---|
| 85 | /**
|
---|
[213] | 86 | * <p>
|
---|
[132] | 87 | * Create the dialog.
|
---|
[213] | 88 | * </p>
|
---|
| 89 | *
|
---|
| 90 | * @param sequences
|
---|
| 91 | * A list of the events where an assertion will be inserted.
|
---|
| 92 | * @param selectedIndex
|
---|
| 93 | * The position for inserting an assertion.
|
---|
| 94 | * @param insertBefore
|
---|
| 95 | * To decide if the user clicked 'insert before' or 'insert
|
---|
| 96 | * after'.
|
---|
[132] | 97 | */
|
---|
[139] | 98 | public DlgInsert(final List<Event<?>> sequences, final int selectedIndex,
|
---|
| 99 | final boolean insertBefore) {
|
---|
[213] | 100 | initialize(sequences, selectedIndex, insertBefore);
|
---|
| 101 | }
|
---|
[139] | 102 |
|
---|
[213] | 103 | /**
|
---|
| 104 | * <p>
|
---|
| 105 | * Initialize the contents of the frame.
|
---|
| 106 | * </p>
|
---|
| 107 | *
|
---|
| 108 | * @param sequences
|
---|
| 109 | * A list of the events where an assertion will be inserted.
|
---|
| 110 | * @param selectedIndex
|
---|
| 111 | * The position for inserting an assertion.
|
---|
| 112 | * @param insertBefore
|
---|
| 113 | * To decide if the user clicked 'insert before' or 'insert
|
---|
| 114 | * after'.
|
---|
| 115 | */
|
---|
| 116 | private void initialize(final List<Event<?>> sequences,
|
---|
| 117 | final int selectedIndex, final boolean insertBefore) {
|
---|
[139] | 118 |
|
---|
[213] | 119 | setResizable(false);
|
---|
| 120 |
|
---|
[132] | 121 | setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
|
---|
| 122 | setTitle("Insert testcase");
|
---|
[139] | 123 |
|
---|
[132] | 124 | setModal(true);
|
---|
[213] | 125 | setBounds(100, 100, 676, 673);
|
---|
[132] | 126 | getContentPane().setLayout(new BorderLayout());
|
---|
| 127 | contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
|
---|
| 128 | getContentPane().add(contentPanel, BorderLayout.CENTER);
|
---|
| 129 | contentPanel.setLayout(null);
|
---|
[213] | 130 | final JComboBox comboBoxAssertionType = new JComboBox();
|
---|
[132] | 131 | final JPanel panelTextEquals = new JPanel();
|
---|
[164] | 132 | panelTextEquals.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null,
|
---|
| 133 | null));
|
---|
[132] | 134 | final JPanel panelFileEquals = new JPanel();
|
---|
[164] | 135 | panelFileEquals.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null,
|
---|
| 136 | null));
|
---|
[139] | 137 |
|
---|
[213] | 138 | // *****
|
---|
| 139 | // define your assertion types here
|
---|
| 140 | final int numberOfAssertionTypes = 2;
|
---|
| 141 | final JPanel[] panels = new JPanel[numberOfAssertionTypes];
|
---|
| 142 | String[] assertionTypes = new String[numberOfAssertionTypes];
|
---|
| 143 |
|
---|
| 144 | panels[0] = panelTextEquals;
|
---|
| 145 | assertionTypes[0] = "TextEquals";
|
---|
| 146 | panels[1] = panelFileEquals;
|
---|
| 147 | assertionTypes[1] = "OutputFileEquals";
|
---|
| 148 | // *****
|
---|
| 149 |
|
---|
| 150 | // add assertion types to comboBox
|
---|
| 151 | for (int i = 0; i < numberOfAssertionTypes; i++) {
|
---|
| 152 | comboBoxAssertionType.addItem(assertionTypes[i]);
|
---|
| 153 | }
|
---|
| 154 |
|
---|
| 155 | comboBoxAssertionType.setSelectedIndex(0);
|
---|
| 156 | comboBoxAssertionType.setBounds(90, 11, 180, 20);
|
---|
| 157 | contentPanel.add(comboBoxAssertionType);
|
---|
| 158 |
|
---|
| 159 | final JPanel buttonPane = new JPanel();
|
---|
| 160 | final JButton okButton = new JButton("Insert");
|
---|
| 161 |
|
---|
| 162 | // selecting of another assertion type
|
---|
| 163 | comboBoxAssertionType.addActionListener(new ActionListener() {
|
---|
[132] | 164 | public void actionPerformed(ActionEvent arg0) {
|
---|
| 165 | if ("comboBoxChanged".equals(arg0.getActionCommand())) {
|
---|
[139] | 166 |
|
---|
[213] | 167 | selectAssertionType(numberOfAssertionTypes, panels,
|
---|
| 168 | comboBoxAssertionType.getSelectedIndex(),
|
---|
| 169 | buttonPane, okButton);
|
---|
[132] | 170 | }
|
---|
| 171 | }
|
---|
| 172 | });
|
---|
[139] | 173 |
|
---|
[132] | 174 | JLabel label = new JLabel("Testcase:");
|
---|
[155] | 175 | label.setBounds(12, 14, 86, 14);
|
---|
[132] | 176 | contentPanel.add(label);
|
---|
[139] | 177 |
|
---|
[132] | 178 | JLabel label_1 = new JLabel("Expected value:");
|
---|
[155] | 179 | label_1.setBounds(10, 11, 96, 14);
|
---|
[139] | 180 |
|
---|
[132] | 181 | JLabel label_2 = new JLabel("Target:");
|
---|
| 182 | label_2.setBounds(10, 38, 86, 14);
|
---|
[139] | 183 |
|
---|
[132] | 184 | textFieldExpectedValue = new JTextField();
|
---|
| 185 | textFieldExpectedValue.setColumns(10);
|
---|
[213] | 186 | textFieldExpectedValue.setBounds(116, 8, 524, 20);
|
---|
[139] | 187 |
|
---|
[132] | 188 | panelTextEquals.setLayout(null);
|
---|
[213] | 189 | panelTextEquals.setBounds(10, 40, 650, 401);
|
---|
[132] | 190 | contentPanel.add(panelTextEquals);
|
---|
| 191 | panelTextEquals.add(label_1);
|
---|
| 192 | panelTextEquals.add(label_2);
|
---|
| 193 | panelTextEquals.add(textFieldExpectedValue);
|
---|
[139] | 194 |
|
---|
[155] | 195 | JScrollPane scrollPane_1 = new JScrollPane();
|
---|
[213] | 196 | scrollPane_1.setBounds(10, 58, 630, 291);
|
---|
[155] | 197 | panelTextEquals.add(scrollPane_1);
|
---|
[139] | 198 |
|
---|
[164] | 199 | final JTree tree = new JTree();
|
---|
| 200 | DefaultTreeModel treeModel = new DefaultTreeModel(null);
|
---|
[213] | 201 | final DefaultMutableTreeNode root = new DefaultMutableTreeNode(
|
---|
| 202 | "Targets");
|
---|
[164] | 203 | treeModel.setRoot(root);
|
---|
| 204 | tree.setModel(treeModel);
|
---|
| 205 |
|
---|
[213] | 206 | tree.getSelectionModel().setSelectionMode(
|
---|
| 207 | TreeSelectionModel.CONTIGUOUS_TREE_SELECTION);
|
---|
| 208 | buildTargetTree(root);
|
---|
[164] | 209 |
|
---|
[213] | 210 | scrollPane_1.setViewportView(tree);
|
---|
[164] | 211 |
|
---|
[213] | 212 | // expand all targets
|
---|
| 213 | JButton btnExpandAll = new JButton("Expand all");
|
---|
| 214 | btnExpandAll.addMouseListener(new MouseAdapter() {
|
---|
| 215 | public void mouseClicked(MouseEvent arg0) {
|
---|
[164] | 216 |
|
---|
[213] | 217 | expandAll(tree, new TreePath(root), true);
|
---|
| 218 | }
|
---|
| 219 | });
|
---|
| 220 | btnExpandAll.setBounds(10, 360, 112, 30);
|
---|
| 221 | panelTextEquals.add(btnExpandAll);
|
---|
[164] | 222 |
|
---|
[213] | 223 | // collapse all targets
|
---|
| 224 | JButton btnCollapseAll = new JButton("Collapse all");
|
---|
| 225 | btnCollapseAll.addMouseListener(new MouseAdapter() {
|
---|
| 226 | public void mouseClicked(MouseEvent arg0) {
|
---|
| 227 | expandAll(tree, new TreePath(root), false);
|
---|
[144] | 228 | }
|
---|
[213] | 229 | });
|
---|
| 230 | btnCollapseAll.setBounds(132, 360, 112, 30);
|
---|
| 231 | panelTextEquals.add(btnCollapseAll);
|
---|
[144] | 232 |
|
---|
[213] | 233 | panelFileEquals.setBounds(34, 452, 607, 120);
|
---|
[132] | 234 | contentPanel.add(panelFileEquals);
|
---|
| 235 | panelFileEquals.setLayout(null);
|
---|
| 236 | panelFileEquals.setVisible(false);
|
---|
[139] | 237 |
|
---|
[134] | 238 | JLabel lblNewLabel = new JLabel("Actual file:");
|
---|
| 239 | lblNewLabel.setBounds(10, 11, 89, 14);
|
---|
[132] | 240 | panelFileEquals.add(lblNewLabel);
|
---|
[139] | 241 |
|
---|
[134] | 242 | textFieldActualFile = new JTextField();
|
---|
[213] | 243 | textFieldActualFile.setBounds(10, 30, 587, 20);
|
---|
[134] | 244 | panelFileEquals.add(textFieldActualFile);
|
---|
| 245 | textFieldActualFile.setColumns(10);
|
---|
[139] | 246 |
|
---|
[213] | 247 | // open search file dialog
|
---|
| 248 | JButton btnSearchFile = new JButton("Search file");
|
---|
| 249 | btnSearchFile.addMouseListener(new MouseAdapter() {
|
---|
[132] | 250 | public void mouseClicked(MouseEvent arg0) {
|
---|
| 251 | final JFileChooser fc = new JFileChooser();
|
---|
[139] | 252 | if (fc.showOpenDialog(contentPanel) == 0) {
|
---|
| 253 | textFieldExpectedFile.setText(fc.getSelectedFile()
|
---|
| 254 | .getAbsolutePath());
|
---|
| 255 | }
|
---|
[132] | 256 | }
|
---|
| 257 | });
|
---|
[213] | 258 | btnSearchFile.setBounds(93, 61, 89, 23);
|
---|
| 259 | panelFileEquals.add(btnSearchFile);
|
---|
[139] | 260 |
|
---|
[134] | 261 | JLabel lblNewLabel_1 = new JLabel("Expected file:");
|
---|
[155] | 262 | lblNewLabel_1.setBounds(10, 70, 89, 14);
|
---|
[132] | 263 | panelFileEquals.add(lblNewLabel_1);
|
---|
[139] | 264 |
|
---|
[134] | 265 | textFieldExpectedFile = new JTextField();
|
---|
| 266 | textFieldExpectedFile.setColumns(10);
|
---|
[213] | 267 | textFieldExpectedFile.setBounds(10, 88, 587, 20);
|
---|
[134] | 268 | panelFileEquals.add(textFieldExpectedFile);
|
---|
[213] | 269 |
|
---|
[132] | 270 | {
|
---|
[164] | 271 | buttonPane.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null,
|
---|
| 272 | null));
|
---|
[213] | 273 | buttonPane.setBounds(12, 583, 607, 51);
|
---|
[155] | 274 | contentPanel.add(buttonPane);
|
---|
[132] | 275 | {
|
---|
[213] | 276 | // clicking 'Insert'
|
---|
| 277 | okButton.setBounds(462, 11, 135, 31);
|
---|
[132] | 278 | okButton.addMouseListener(new MouseAdapter() {
|
---|
| 279 | public void mouseClicked(MouseEvent arg0) {
|
---|
[213] | 280 | if (insertAssertion(sequences, selectedIndex,
|
---|
| 281 | insertBefore, tree, comboBoxAssertionType
|
---|
| 282 | .getSelectedItem().toString()) == false) {
|
---|
| 283 | return;
|
---|
[132] | 284 | }
|
---|
[139] | 285 |
|
---|
[132] | 286 | dispose();
|
---|
| 287 | }
|
---|
| 288 | });
|
---|
[155] | 289 | buttonPane.setLayout(null);
|
---|
[132] | 290 | okButton.setActionCommand("OK");
|
---|
| 291 | buttonPane.add(okButton);
|
---|
| 292 | getRootPane().setDefaultButton(okButton);
|
---|
| 293 | }
|
---|
[139] | 294 |
|
---|
[132] | 295 | {
|
---|
[213] | 296 | // clicking 'Cancel'
|
---|
[132] | 297 | JButton cancelButton = new JButton("Cancel");
|
---|
[155] | 298 | cancelButton.setBounds(10, 11, 135, 31);
|
---|
[132] | 299 | cancelButton.addMouseListener(new MouseAdapter() {
|
---|
[139] | 300 |
|
---|
| 301 | public void mouseClicked(MouseEvent arg0) {
|
---|
| 302 | dispose();
|
---|
| 303 | }
|
---|
[132] | 304 | });
|
---|
| 305 | cancelButton.setActionCommand("Cancel");
|
---|
| 306 | buttonPane.add(cancelButton);
|
---|
| 307 | }
|
---|
| 308 | }
|
---|
[213] | 309 |
|
---|
| 310 | selectAssertionType(numberOfAssertionTypes, panels,
|
---|
| 311 | comboBoxAssertionType.getSelectedIndex(),
|
---|
| 312 | buttonPane, okButton);
|
---|
[132] | 313 | }
|
---|
[164] | 314 |
|
---|
[213] | 315 | /**
|
---|
| 316 | * Build up the tree containing all available targets.
|
---|
| 317 | *
|
---|
| 318 | * @param root
|
---|
| 319 | * The tree root.
|
---|
| 320 | */
|
---|
| 321 | @SuppressWarnings("unchecked")
|
---|
| 322 | private void buildTargetTree(final DefaultMutableTreeNode root) {
|
---|
| 323 | // get targets from GlobalDataContainer
|
---|
| 324 | SortedSet<String> listTargets = new TreeSet<String>();
|
---|
| 325 | try {
|
---|
| 326 | listTargets = (SortedSet<String>) GlobalDataContainer.getInstance()
|
---|
| 327 | .getData("ListTargets");
|
---|
| 328 | } catch (ClassCastException e) {
|
---|
| 329 | Console.println("Not able to cast data in GlobalDataContainer to SortedSet of Strings");
|
---|
| 330 | }
|
---|
| 331 |
|
---|
| 332 | // build the tree
|
---|
| 333 | for (String target : listTargets) {
|
---|
| 334 | DefaultMutableTreeNode currentParent = root;
|
---|
| 335 |
|
---|
| 336 | String splitted[] = target.split("/>");
|
---|
| 337 |
|
---|
| 338 | for (String targetPart : splitted) {
|
---|
| 339 | DefaultMutableTreeNode node = compareTargetWithNode(
|
---|
| 340 | currentParent, targetPart + "/>");
|
---|
| 341 |
|
---|
| 342 | if (node != null) {
|
---|
| 343 | currentParent = node;
|
---|
| 344 | } else {
|
---|
| 345 | node = new DefaultMutableTreeNode(targetPart + "/>");
|
---|
| 346 | currentParent.add(node);
|
---|
| 347 | currentParent = node;
|
---|
| 348 | }
|
---|
| 349 | }
|
---|
| 350 | }
|
---|
| 351 | }
|
---|
| 352 |
|
---|
| 353 | /**
|
---|
| 354 | * Check if there is a child equal to 'target'.
|
---|
| 355 | *
|
---|
| 356 | * @param node
|
---|
| 357 | * The parent node which is browsed for a node equal to 'target'.
|
---|
| 358 | * @param target
|
---|
| 359 | * 'node' is browsed for this String.
|
---|
| 360 | * @return If there was no fitting node found, the return value is null.
|
---|
| 361 | * Otherwise it is the node.
|
---|
| 362 | */
|
---|
[164] | 363 | DefaultMutableTreeNode compareTargetWithNode(DefaultMutableTreeNode node,
|
---|
| 364 | String target) {
|
---|
| 365 |
|
---|
| 366 | if (node.isLeaf()) {
|
---|
| 367 | if (target.contains(node.toString()))
|
---|
| 368 | return node;
|
---|
| 369 | else
|
---|
| 370 | return null;
|
---|
| 371 | } else {
|
---|
| 372 | for (@SuppressWarnings("unchecked")
|
---|
| 373 | Enumeration<DefaultMutableTreeNode> e = node.children(); e
|
---|
| 374 | .hasMoreElements();) {
|
---|
| 375 | DefaultMutableTreeNode nodeReturn = compareTargetWithNode(
|
---|
| 376 | e.nextElement(), target);
|
---|
| 377 | if (nodeReturn == null) {
|
---|
[213] | 378 | if (target.contains(node.toString())) {
|
---|
[164] | 379 | return node;
|
---|
[213] | 380 | }
|
---|
| 381 | } else {
|
---|
[164] | 382 | return nodeReturn;
|
---|
[213] | 383 | }
|
---|
[164] | 384 | }
|
---|
| 385 | }
|
---|
| 386 |
|
---|
| 387 | return null;
|
---|
| 388 | }
|
---|
[213] | 389 |
|
---|
| 390 | /**
|
---|
| 391 | * Expand or collapse the target tree.
|
---|
| 392 | *
|
---|
| 393 | * @param tree
|
---|
| 394 | * The tree itself.
|
---|
| 395 | * @param parent
|
---|
| 396 | * The parent node which has to be expanded/collapsed.
|
---|
| 397 | * @param expand
|
---|
| 398 | * To choose wether it is expanded or collapsed.
|
---|
| 399 | */
|
---|
| 400 | private void expandAll(JTree tree, TreePath parent, boolean expand) {
|
---|
| 401 | // Traverse children
|
---|
| 402 | TreeNode node = (TreeNode) parent.getLastPathComponent();
|
---|
| 403 | if (node.getChildCount() >= 0) {
|
---|
| 404 | for (@SuppressWarnings("unchecked")
|
---|
| 405 | Enumeration<DefaultMutableTreeNode> e = node.children(); e
|
---|
| 406 | .hasMoreElements();) {
|
---|
| 407 | TreeNode n = (TreeNode) e.nextElement();
|
---|
| 408 | TreePath path = parent.pathByAddingChild(n);
|
---|
| 409 | expandAll(tree, path, expand);
|
---|
| 410 | }
|
---|
| 411 | }
|
---|
| 412 |
|
---|
| 413 | // Expansion or collapse must be done bottom-up
|
---|
| 414 | if (expand) {
|
---|
| 415 | tree.expandPath(parent);
|
---|
| 416 | } else {
|
---|
| 417 | tree.collapsePath(parent);
|
---|
| 418 | }
|
---|
| 419 | }
|
---|
| 420 |
|
---|
| 421 | /**
|
---|
| 422 | * Select another assertion type in the comboBox.
|
---|
| 423 | *
|
---|
| 424 | * @param numberOfAssertionTypes
|
---|
| 425 | * Number of available assertion types.
|
---|
| 426 | * @param panels
|
---|
| 427 | * The corresponding panels of the types.
|
---|
| 428 | * @param selectedIndex
|
---|
| 429 | * The index of the selected type.
|
---|
| 430 | * @param buttonPane
|
---|
| 431 | * The buttonPane of the dialog.
|
---|
| 432 | * @param okButton
|
---|
| 433 | * The okButton of the buttonPane.
|
---|
| 434 | */
|
---|
| 435 | private void selectAssertionType(final int numberOfAssertionTypes,
|
---|
| 436 | final JPanel[] panels, int selectedIndex, final JPanel buttonPane,
|
---|
| 437 | final JButton okButton) {
|
---|
| 438 | for (int i = 0; i < numberOfAssertionTypes; i++) {
|
---|
| 439 | panels[i].setVisible(false);
|
---|
| 440 | }
|
---|
| 441 |
|
---|
| 442 | JPanel activePanel = panels[selectedIndex];
|
---|
| 443 | activePanel.setVisible(true);
|
---|
| 444 | activePanel.setLocation(10, 40);
|
---|
| 445 |
|
---|
| 446 | buttonPane.setLocation(activePanel.getX(), activePanel.getY()
|
---|
| 447 | + activePanel.getHeight() + 15);
|
---|
| 448 | buttonPane.setSize(activePanel.getWidth(), buttonPane.getHeight());
|
---|
| 449 | setSize(activePanel.getX() + activePanel.getSize().width + 15,
|
---|
| 450 | buttonPane.getY() + buttonPane.getSize().height + 35);
|
---|
| 451 | okButton.setLocation(buttonPane.getWidth() - okButton.getWidth() - 10,
|
---|
| 452 | okButton.getY());
|
---|
| 453 |
|
---|
| 454 | }
|
---|
| 455 |
|
---|
| 456 | /**
|
---|
| 457 | * To check if all the parameters needed where entered correctly.
|
---|
| 458 | *
|
---|
| 459 | * @param sequences
|
---|
| 460 | * A list of the events where an assertion will be inserted.
|
---|
| 461 | * @param selectedIndex
|
---|
| 462 | * The position for inserting an assertion.
|
---|
| 463 | * @param insertBefore
|
---|
| 464 | * To decide if the user clicked 'insert before' or 'insert
|
---|
| 465 | * after'.
|
---|
| 466 | * @param tree
|
---|
| 467 | * The target tree.
|
---|
| 468 | * @param selectedItem
|
---|
| 469 | * To identify the selected assertion type.
|
---|
| 470 | * @return If the assertion was inserted, the return value is true.
|
---|
| 471 | * Otherwise it is false.
|
---|
| 472 | */
|
---|
| 473 | private boolean insertAssertion(final List<Event<?>> sequences,
|
---|
| 474 | final int selectedIndex, final boolean insertBefore,
|
---|
| 475 | final JTree tree, final String selectedItem) {
|
---|
| 476 |
|
---|
| 477 | // FileEquals
|
---|
| 478 | if (selectedItem == "OutputFileEquals") {
|
---|
| 479 | if (textFieldActualFile.getText().length() == 0) {
|
---|
| 480 | JOptionPane.showMessageDialog(null,
|
---|
| 481 | "Please declare an actual file.",
|
---|
| 482 | "No actual file declared", JOptionPane.OK_OPTION);
|
---|
| 483 |
|
---|
| 484 | return false;
|
---|
| 485 | } else if (!new File(textFieldExpectedFile.getText()).exists()) {
|
---|
| 486 | if (textFieldExpectedFile.getText().length() == 0) {
|
---|
| 487 | JOptionPane.showMessageDialog(null,
|
---|
| 488 | "Please choose an expected file.",
|
---|
| 489 | "No expected file chosen", JOptionPane.OK_OPTION);
|
---|
| 490 | } else {
|
---|
| 491 | JOptionPane.showMessageDialog(null, "The expected file \""
|
---|
| 492 | + textFieldActualFile.getText()
|
---|
| 493 | + "\" does not exist.",
|
---|
| 494 | "Expected file does not exist",
|
---|
| 495 | JOptionPane.OK_OPTION);
|
---|
| 496 | }
|
---|
| 497 |
|
---|
| 498 | return false;
|
---|
| 499 | } else {
|
---|
| 500 | FileEqualsReplay file = new FileEqualsReplay();
|
---|
| 501 | file.setActualFile(textFieldActualFile.getText());
|
---|
| 502 | file.setExpectedFile(textFieldExpectedFile.getText());
|
---|
| 503 |
|
---|
| 504 | AssertEvent<FileEqualsReplay> e = new AssertEvent<FileEqualsReplay>(
|
---|
| 505 | "FileEquals");
|
---|
| 506 | e.addReplayEvent(file);
|
---|
| 507 | e.setTarget(" ");
|
---|
| 508 | if (insertBefore)
|
---|
| 509 | sequences.add(selectedIndex, e);
|
---|
| 510 | else
|
---|
| 511 | sequences.add(selectedIndex + 1, e);
|
---|
| 512 | }
|
---|
| 513 | }
|
---|
| 514 | // TextEquals
|
---|
| 515 | else if (selectedItem == "TextEquals") {
|
---|
| 516 | if (textFieldExpectedValue.getText().length() == 0) {
|
---|
| 517 | JOptionPane.showMessageDialog(null,
|
---|
| 518 | "\"Expected value\" is missing.", "Expected value",
|
---|
| 519 | JOptionPane.OK_OPTION);
|
---|
| 520 | return false;
|
---|
| 521 | } else if (tree.getSelectionCount() == 0
|
---|
| 522 | || tree.getSelectionPath().toString()
|
---|
| 523 | .compareTo("[Targets]") == 0) {
|
---|
| 524 | JOptionPane.showMessageDialog(null, "Please select a target.",
|
---|
| 525 | "No target selected", JOptionPane.OK_OPTION);
|
---|
| 526 | return false;
|
---|
| 527 | } else {
|
---|
| 528 |
|
---|
| 529 | // get target ***
|
---|
| 530 | String selectionPath = tree.getSelectionPath().toString();
|
---|
| 531 |
|
---|
| 532 | // remove leading and ending brackets
|
---|
| 533 | selectionPath = selectionPath.substring(1);
|
---|
| 534 | selectionPath = selectionPath.substring(0,
|
---|
| 535 | selectionPath.length() - 1);
|
---|
| 536 | // remove leading string "targets"
|
---|
| 537 | selectionPath = selectionPath.substring(7);
|
---|
| 538 |
|
---|
| 539 | String splitted[] = selectionPath.toString().split(", ");
|
---|
| 540 |
|
---|
| 541 | // get all parents
|
---|
| 542 | String target = "";
|
---|
| 543 | for (int i = 0; i < splitted.length; i++) {
|
---|
| 544 | target += splitted[i];
|
---|
| 545 | }
|
---|
| 546 | // ***
|
---|
| 547 |
|
---|
| 548 | TextEqualsReplay text = new TextEqualsReplay();
|
---|
| 549 | text.setExpectedValue(textFieldExpectedValue.getText());
|
---|
| 550 | text.setTarget(target);
|
---|
| 551 |
|
---|
| 552 | AssertEvent<TextEqualsReplay> e = new AssertEvent<TextEqualsReplay>(
|
---|
| 553 | "TextEquals");
|
---|
| 554 | e.addReplayEvent(text);
|
---|
| 555 | e.setTarget(" ");
|
---|
| 556 | if (insertBefore)
|
---|
| 557 | sequences.add(selectedIndex, e);
|
---|
| 558 | else
|
---|
| 559 | sequences.add(selectedIndex + 1, e);
|
---|
| 560 | }
|
---|
| 561 | }
|
---|
| 562 |
|
---|
| 563 | return true;
|
---|
| 564 | }
|
---|
[164] | 565 | } |
---|