1
2
3
4
5
6
7
8
9
10
11
12
13 package com.eviware.soapui.impl.wsdl.panels.teststeps;
14
15 import java.awt.BorderLayout;
16 import java.awt.Component;
17 import java.awt.Dimension;
18 import java.awt.GridLayout;
19 import java.awt.event.ActionEvent;
20 import java.awt.event.ItemEvent;
21 import java.awt.event.ItemListener;
22 import java.beans.PropertyChangeEvent;
23 import java.beans.PropertyChangeListener;
24 import java.util.ArrayList;
25 import java.util.Arrays;
26 import java.util.Date;
27 import java.util.List;
28
29 import javax.swing.AbstractAction;
30 import javax.swing.Action;
31 import javax.swing.BorderFactory;
32 import javax.swing.DefaultComboBoxModel;
33 import javax.swing.DefaultListCellRenderer;
34 import javax.swing.DefaultListModel;
35 import javax.swing.JButton;
36 import javax.swing.JCheckBox;
37 import javax.swing.JComboBox;
38 import javax.swing.JComponent;
39 import javax.swing.JLabel;
40 import javax.swing.JList;
41 import javax.swing.JPanel;
42 import javax.swing.JScrollPane;
43 import javax.swing.JSplitPane;
44 import javax.swing.JTextArea;
45 import javax.swing.JToggleButton;
46 import javax.swing.ListSelectionModel;
47 import javax.swing.event.ChangeEvent;
48 import javax.swing.event.ChangeListener;
49 import javax.swing.event.ListSelectionEvent;
50 import javax.swing.event.ListSelectionListener;
51 import javax.swing.table.AbstractTableModel;
52 import javax.swing.text.Document;
53
54 import org.jdesktop.swingx.JXTable;
55
56 import com.eviware.soapui.SoapUI;
57 import com.eviware.soapui.impl.support.actions.ShowOnlineHelpAction;
58 import com.eviware.soapui.impl.wsdl.panels.support.MockTestRunContext;
59 import com.eviware.soapui.impl.wsdl.panels.support.MockTestRunner;
60 import com.eviware.soapui.impl.wsdl.panels.support.TestRunComponentEnabler;
61 import com.eviware.soapui.impl.wsdl.support.HelpUrls;
62 import com.eviware.soapui.impl.wsdl.teststeps.PropertyTransfer;
63 import com.eviware.soapui.impl.wsdl.teststeps.PropertyTransfersTestStep;
64 import com.eviware.soapui.impl.wsdl.teststeps.WsdlTestRequest;
65 import com.eviware.soapui.impl.wsdl.teststeps.WsdlTestRequestStep;
66 import com.eviware.soapui.impl.wsdl.teststeps.WsdlTestStep;
67 import com.eviware.soapui.impl.wsdl.teststeps.PropertyTransfersTestStep.PropertyTransferResult;
68 import com.eviware.soapui.model.ModelItem;
69 import com.eviware.soapui.model.TestModelItem;
70 import com.eviware.soapui.model.TestPropertyHolder;
71 import com.eviware.soapui.model.propertyexpansion.PropertyExpansion;
72 import com.eviware.soapui.model.propertyexpansion.PropertyExpansionUtils;
73 import com.eviware.soapui.model.support.TestRunListenerAdapter;
74 import com.eviware.soapui.model.support.TestSuiteListenerAdapter;
75 import com.eviware.soapui.model.testsuite.TestCaseRunContext;
76 import com.eviware.soapui.model.testsuite.TestCaseRunner;
77 import com.eviware.soapui.model.testsuite.TestProperty;
78 import com.eviware.soapui.model.testsuite.TestPropertyListener;
79 import com.eviware.soapui.model.testsuite.TestStep;
80 import com.eviware.soapui.model.testsuite.TestStepResult;
81 import com.eviware.soapui.support.DocumentListenerAdapter;
82 import com.eviware.soapui.support.UISupport;
83 import com.eviware.soapui.support.components.JComponentInspector;
84 import com.eviware.soapui.support.components.JInspectorPanel;
85 import com.eviware.soapui.support.components.JInspectorPanelFactory;
86 import com.eviware.soapui.support.components.JUndoableTextArea;
87 import com.eviware.soapui.support.components.JXToolBar;
88 import com.eviware.soapui.support.xml.XmlUtils;
89 import com.eviware.soapui.ui.desktop.DesktopPanel;
90 import com.eviware.soapui.ui.support.ModelItemDesktopPanel;
91
92 /***
93 * DesktopPanel for TransferResponseValuesTestStep
94 *
95 * @author Ole.Matzura
96 */
97
98 public class PropertyTransfersDesktopPanel extends ModelItemDesktopPanel<PropertyTransfersTestStep>
99 {
100 private final PropertyTransfersTestStep transferStep;
101 private DefaultListModel listModel;
102 private JList transferList;
103 private JTextArea sourceArea;
104 private JTextArea targetArea;
105 private JButton copyButton;
106 private JButton deleteButton;
107 private JButton declareButton;
108 private JComboBox sourcePropertyCombo;
109 private JComboBox targetPropertyCombo;
110 private JComboBox sourceStepCombo;
111 private JComboBox targetStepCombo;
112 private DefaultComboBoxModel sourceStepModel;
113 private DefaultComboBoxModel targetStepModel;
114 private TestStepPropertiesListener sourceStepPropertiesListener;
115 private TestStepPropertiesListener targetStepPropertiesListener;
116 private TransferPropertyChangeListener transferPropertyChangeListener = new TransferPropertyChangeListener();
117 private boolean selecting;
118 private InternalTestSuiteListener testSuiteListener;
119 private TestRunComponentEnabler componentEnabler;
120 private JCheckBox failTransferCheckBox;
121 private JButton runButton;
122 private JButton renameButton;
123 private JCheckBox setNullCheckBox;
124 private JCheckBox transferTextContentCheckBox;
125 private JCheckBox ignoreEmptyCheckBox;
126 private JCheckBox transferAllCheckBox;
127 private JCheckBox entitizeCheckBox;
128 private JCheckBox transferChildNodesCheckBox;
129 private DesktopPanel resultDesktopPanel;
130 private TransfersTableModel transferLogTableModel;
131 private InternalTestRunListener testRunListener;
132 private JComponentInspector<JComponent> logInspector;
133 private JCheckBox useXQueryCheckBox;
134 private JButton runAllButton;
135 private JInspectorPanel inspectorPanel;
136 private JXTable logTable;
137 private JToggleButton disableButton;
138
139 public PropertyTransfersDesktopPanel(PropertyTransfersTestStep testStep)
140 {
141 super(testStep);
142 this.transferStep = testStep;
143 componentEnabler = new TestRunComponentEnabler(testStep.getTestCase());
144
145 buildUI();
146
147 testSuiteListener = new InternalTestSuiteListener();
148 transferStep.getTestCase().getTestSuite().addTestSuiteListener(testSuiteListener);
149
150 testRunListener = new InternalTestRunListener();
151 transferStep.getTestCase().addTestRunListener(testRunListener);
152 }
153
154 protected void buildUI()
155 {
156 JSplitPane splitPane = UISupport.createHorizontalSplit();
157
158 listModel = new DefaultListModel();
159
160 for (int c = 0; c < transferStep.getTransferCount(); c++)
161 {
162 String name = transferStep.getTransferAt(c).getName();
163 if (transferStep.getTransferAt(c).isDisabled())
164 name += " (disabled)";
165
166 listModel.addElement(name);
167 }
168
169 transferList = new JList(listModel);
170 transferList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
171 transferList.addListSelectionListener(new TransferListSelectionListener());
172 componentEnabler.add(transferList);
173
174 JScrollPane listScrollPane = new JScrollPane(transferList);
175 UISupport.addTitledBorder(listScrollPane, "Transfers");
176
177 JPanel p = new JPanel(new BorderLayout());
178 p.add(listScrollPane, BorderLayout.CENTER);
179 p.add(createPropertiesToolbar(), BorderLayout.NORTH);
180
181 splitPane.setLeftComponent(p);
182
183 JSplitPane innerSplit = UISupport.createVerticalSplit();
184 innerSplit.setBorder(null);
185 sourceArea = new JUndoableTextArea();
186 sourceArea.setToolTipText("XPath selection from source property");
187 sourceArea.setEnabled(false);
188 sourceArea.getDocument().addDocumentListener(new SourceAreaDocumentListener());
189 componentEnabler.add(sourceArea);
190
191 targetArea = new JUndoableTextArea();
192 targetArea.setToolTipText("XPath target in target property");
193 targetArea.setEnabled(false);
194 targetArea.getDocument().addDocumentListener(new TargetAreaDocumentListener());
195 componentEnabler.add(targetArea);
196
197 JPanel sourcePanel = new JPanel(new BorderLayout());
198 sourcePanel.add(new JScrollPane(sourceArea), BorderLayout.CENTER);
199 JXToolBar toolbar = createSourceToolbar();
200 sourcePanel.add(toolbar, BorderLayout.NORTH);
201 sourcePanel.setBorder(BorderFactory.createEmptyBorder(0, 3, 3, 3));
202 innerSplit.setTopComponent(sourcePanel);
203
204 JPanel targetPanel = new JPanel(new BorderLayout());
205 targetPanel.add(new JScrollPane(targetArea), BorderLayout.CENTER);
206 toolbar = createTargetToolbar();
207 targetPanel.add(toolbar, BorderLayout.NORTH);
208 targetPanel.setBorder(BorderFactory.createEmptyBorder(0, 3, 3, 3));
209
210 innerSplit.setBottomComponent(targetPanel);
211
212 innerSplit.setResizeWeight(0.5);
213 innerSplit.setDividerLocation(0.5);
214
215 JPanel panel = createTransferOptions();
216
217 JPanel innerPanel = new JPanel(new BorderLayout());
218 innerPanel.add(innerSplit, BorderLayout.CENTER);
219 innerPanel.add(panel, BorderLayout.SOUTH);
220 innerPanel.add(createConfigToolbar(), BorderLayout.NORTH);
221
222 splitPane.setRightComponent(innerPanel);
223 splitPane.setResizeWeight(0.1);
224 splitPane.setDividerLocation(120);
225
226 inspectorPanel = JInspectorPanelFactory.build(splitPane);
227 logInspector = new JComponentInspector<JComponent>(buildLog(), "Transfer Log (0)",
228 "A log of performed transfers while the editor was open", true);
229 inspectorPanel.addInspector(logInspector);
230 add(inspectorPanel.getComponent(), BorderLayout.CENTER);
231
232 setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
233 setPreferredSize(new Dimension(550, 400));
234
235 if (listModel.getSize() > 0)
236 transferList.setSelectedIndex(0);
237 else
238 setSelectedTransfer(null);
239
240 componentEnabler.add(deleteButton);
241 componentEnabler.add(declareButton);
242 componentEnabler.add(runButton);
243 componentEnabler.add(runAllButton);
244 componentEnabler.add(copyButton);
245 componentEnabler.add(renameButton);
246 componentEnabler.add(failTransferCheckBox);
247 componentEnabler.add(setNullCheckBox);
248 componentEnabler.add(transferTextContentCheckBox);
249 componentEnabler.add(ignoreEmptyCheckBox);
250 componentEnabler.add(transferAllCheckBox);
251 componentEnabler.add(useXQueryCheckBox);
252 componentEnabler.add(entitizeCheckBox);
253 componentEnabler.add(transferChildNodesCheckBox);
254
255 }
256
257 private JComponent buildLog()
258 {
259 JPanel logPanel = new JPanel(new BorderLayout());
260
261 transferLogTableModel = new TransfersTableModel();
262 logTable = new JXTable(transferLogTableModel);
263 logTable.getSelectionModel().addListSelectionListener(new ListSelectionListener()
264 {
265
266 public void valueChanged(ListSelectionEvent e)
267 {
268 int row = logTable.getSelectedRow();
269 if (row != -1)
270 {
271 String transferName = transferLogTableModel.getValueAt(row, 1).toString();
272 int ix = listModel.indexOf(transferName);
273 if (ix != -1)
274 {
275 transferList.setSelectedIndex(ix);
276 }
277 }
278 }
279 });
280
281 logTable.setHorizontalScrollEnabled(true);
282 logTable.packAll();
283
284 JXToolBar toolbar = UISupport.createSmallToolbar();
285 toolbar.add(new ClearLogAction());
286
287 JScrollPane scrollPane = new JScrollPane(logTable);
288 scrollPane.setBorder( BorderFactory.createCompoundBorder( BorderFactory.createEmptyBorder( 3, 3, 3, 3 ),
289 scrollPane.getBorder() ) );
290
291 logPanel.add(toolbar, BorderLayout.NORTH);
292 logPanel.add(scrollPane, BorderLayout.CENTER);
293
294 return logPanel;
295 }
296
297 protected JXToolBar createPropertiesToolbar()
298 {
299 JXToolBar toolbar = UISupport.createSmallToolbar();
300 toolbar.addFixed(UISupport.createToolbarButton(new AddAction()));
301 deleteButton = UISupport.createToolbarButton(new DeleteAction());
302 deleteButton.setEnabled(false);
303 toolbar.addFixed(deleteButton);
304 copyButton = UISupport.createToolbarButton(new CopyAction());
305 copyButton.setEnabled(false);
306 toolbar.addFixed(copyButton);
307 renameButton = UISupport.createToolbarButton(new RenameAction());
308 renameButton.setEnabled(false);
309 toolbar.addFixed(renameButton);
310
311 disableButton = new JToggleButton(new DisableAction());
312 disableButton.setPreferredSize(UISupport.TOOLBAR_BUTTON_DIMENSION);
313 disableButton.setSelectedIcon(UISupport.createImageIcon("/bullet_red.png"));
314 toolbar.addSeparator();
315 toolbar.addFixed(disableButton);
316
317 return toolbar;
318 }
319
320 protected JXToolBar createConfigToolbar()
321 {
322 JXToolBar toolbar = UISupport.createToolbar();
323
324 toolbar.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
325
326 runButton = UISupport.createToolbarButton(new RunAction());
327 runButton.setEnabled(transferList.getSelectedIndex() != -1);
328 toolbar.addFixed(runButton);
329
330 runAllButton = UISupport.createToolbarButton(new RunAllAction());
331 runAllButton.setEnabled(transferStep.getTransferCount() > 0);
332 toolbar.addFixed(runAllButton);
333
334 declareButton = UISupport.createToolbarButton(new DeclareNamespacesAction());
335 declareButton.setEnabled(false);
336 toolbar.addFixed(declareButton);
337 toolbar.addGlue();
338 toolbar.addFixed( UISupport
339 .createToolbarButton( new ShowOnlineHelpAction( HelpUrls.TRANSFERSTEPEDITOR_HELP_URL ) ) );
340 return toolbar;
341 }
342
343 protected JPanel createTransferOptions()
344 {
345 JPanel panel = new JPanel(new GridLayout(4, 2));
346 failTransferCheckBox = new JCheckBox("Fail transfer on error", false);
347 failTransferCheckBox.setToolTipText("Fails the Property Transfer Step if an error occurs");
348 failTransferCheckBox.addChangeListener(new ChangeListener()
349 {
350
351 public void stateChanged(ChangeEvent e)
352 {
353 PropertyTransfer currentTransfer = getCurrentTransfer();
354 if (currentTransfer != null)
355 {
356 currentTransfer.setFailOnError(failTransferCheckBox.isSelected());
357 }
358 }
359 });
360
361 setNullCheckBox = new JCheckBox("Set null on missing source", false);
362 setNullCheckBox.setToolTipText("Will set target to null if source is missing or null");
363 setNullCheckBox.addChangeListener(new ChangeListener()
364 {
365
366 public void stateChanged(ChangeEvent e)
367 {
368 PropertyTransfer currentTransfer = getCurrentTransfer();
369 if (currentTransfer != null)
370 {
371 currentTransfer.setSetNullOnMissingSource(setNullCheckBox.isSelected());
372 }
373 }
374 });
375
376 transferTextContentCheckBox = new JCheckBox("Transfer text content", false);
377 transferTextContentCheckBox.setToolTipText("Will only transfer text content of source/target elements");
378 transferTextContentCheckBox.addChangeListener(new ChangeListener()
379 {
380
381 public void stateChanged(ChangeEvent e)
382 {
383 PropertyTransfer currentTransfer = getCurrentTransfer();
384 if (currentTransfer != null)
385 {
386 currentTransfer.setTransferTextContent(transferTextContentCheckBox.isSelected());
387 }
388 }
389 });
390
391 ignoreEmptyCheckBox = new JCheckBox("Ignore empty/missing values", false);
392 ignoreEmptyCheckBox.setToolTipText("Will not transfer empty or missing values");
393 ignoreEmptyCheckBox.addChangeListener(new ChangeListener()
394 {
395
396 public void stateChanged(ChangeEvent e)
397 {
398 PropertyTransfer currentTransfer = getCurrentTransfer();
399 if (currentTransfer != null)
400 {
401 currentTransfer.setIgnoreEmpty(ignoreEmptyCheckBox.isSelected());
402 }
403 }
404 });
405
406 transferAllCheckBox = new JCheckBox("Transfer to all", false);
407 transferAllCheckBox.setToolTipText("Will transfer to all matching target selections");
408 transferAllCheckBox.addChangeListener(new ChangeListener()
409 {
410
411 public void stateChanged(ChangeEvent e)
412 {
413 PropertyTransfer currentTransfer = getCurrentTransfer();
414 if (currentTransfer != null)
415 {
416 currentTransfer.setTransferToAll(transferAllCheckBox.isSelected());
417 }
418 }
419 });
420
421 useXQueryCheckBox = new JCheckBox("Use XQuery", false);
422 useXQueryCheckBox.setToolTipText("Interprets the source xpath as an XQuery expression");
423 useXQueryCheckBox.addChangeListener(new ChangeListener()
424 {
425
426 public void stateChanged(ChangeEvent e)
427 {
428 PropertyTransfer currentTransfer = getCurrentTransfer();
429 if (currentTransfer != null)
430 {
431 currentTransfer.setUseXQuery(useXQueryCheckBox.isSelected());
432 }
433 }
434 });
435
436 entitizeCheckBox = new JCheckBox("Entitize transferred value(s)", false);
437 entitizeCheckBox.setToolTipText("Entitize transferred values when possible");
438 entitizeCheckBox.addChangeListener(new ChangeListener()
439 {
440
441 public void stateChanged(ChangeEvent e)
442 {
443 PropertyTransfer currentTransfer = getCurrentTransfer();
444 if (currentTransfer != null)
445 {
446 currentTransfer.setEntitize(entitizeCheckBox.isSelected());
447 }
448 }
449 });
450
451 transferChildNodesCheckBox = new JCheckBox("Transfer Child Nodes", false);
452 transferChildNodesCheckBox
453 .setToolTipText("Transfers child nodes of specified source node to children of specified target");
454 transferChildNodesCheckBox.addChangeListener(new ChangeListener()
455 {
456
457 public void stateChanged(ChangeEvent e)
458 {
459 PropertyTransfer currentTransfer = getCurrentTransfer();
460 if (currentTransfer != null)
461 {
462 currentTransfer.setTransferChildNodes(transferChildNodesCheckBox.isSelected());
463 }
464 }
465 });
466
467 panel.add(failTransferCheckBox);
468 panel.add(setNullCheckBox);
469 panel.add(transferTextContentCheckBox);
470 panel.add(ignoreEmptyCheckBox);
471 panel.add(transferAllCheckBox);
472 panel.add(useXQueryCheckBox);
473 panel.add(entitizeCheckBox);
474 panel.add(transferChildNodesCheckBox);
475 panel.setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
476 return panel;
477 }
478
479 protected JXToolBar createTargetToolbar()
480 {
481 JXToolBar toolbar;
482 toolbar = UISupport.createToolbar();
483 toolbar.addSpace(3);
484 toolbar.addFixed(new JLabel("<html><b>Target:</b></html>"));
485 toolbar.addUnrelatedGap();
486
487 targetStepCombo.setSelectedItem(null);
488 targetStepCombo.setToolTipText("The step the value will be transferred to");
489 targetStepCombo.setEnabled(false);
490 targetStepCombo.addItemListener(new StepComboItemListener(targetPropertyCombo, targetStepPropertiesListener));
491 targetStepCombo.addItemListener(new ItemListener()
492 {
493
494 public void itemStateChanged(ItemEvent e)
495 {
496 if (e.getStateChange() == ItemEvent.SELECTED && !selecting)
497 {
498 TestPropertyHolder targetStep = (TestPropertyHolder) targetStepCombo.getSelectedItem();
499 PropertyTransfer valueTransfer = getCurrentTransfer();
500
501 if (valueTransfer != null)
502 {
503 String name = "";
504
505 if (targetStep == PropertyExpansionUtils.getGlobalProperties())
506 name = PropertyExpansion.GLOBAL_REFERENCE;
507 else if (targetStep == transferStep.getTestCase().getTestSuite().getProject())
508 name = PropertyExpansion.PROJECT_REFERENCE;
509 else if (targetStep == transferStep.getTestCase().getTestSuite())
510 name = PropertyExpansion.TESTSUITE_REFERENCE;
511 else if (targetStep == transferStep.getTestCase())
512 name = PropertyExpansion.TESTCASE_REFERENCE;
513 else
514 name = targetStep.getModelItem().getName();
515
516 valueTransfer.setTargetStepName(name);
517 }
518 }
519 }
520 });
521
522 toolbar.add(UISupport.setFixedSize(targetStepCombo, 200, 21));
523 toolbar.addUnrelatedGap();
524
525 toolbar.addFixed(new JLabel("Property:"));
526 toolbar.addRelatedGap();
527
528 targetPropertyCombo.setToolTipText("The property the value will be transferred to");
529 targetPropertyCombo.setEnabled(false);
530 targetPropertyCombo.addItemListener(new ItemListener()
531 {
532
533 public void itemStateChanged(ItemEvent e)
534 {
535 if (e.getStateChange() == ItemEvent.SELECTED && !selecting)
536 {
537 TestProperty targetProperty = (TestProperty) targetPropertyCombo.getSelectedItem();
538 PropertyTransfer valueTransfer = getCurrentTransfer();
539
540 if (valueTransfer != null)
541 {
542 valueTransfer.setTargetPropertyName(targetProperty.getName());
543 }
544 }
545 }
546 });
547
548 toolbar.add(UISupport.setFixedSize(targetPropertyCombo, 200, 21));
549 toolbar.addGlue();
550 return toolbar;
551 }
552
553 protected JXToolBar createSourceToolbar()
554 {
555 JXToolBar toolbar = UISupport.createToolbar();
556 toolbar.addSpace(3);
557 toolbar.addFixed(new JLabel("<html><b>Source:</b></html>"));
558 toolbar.addUnrelatedGap();
559
560 sourcePropertyCombo = UISupport.addTooltipListener(new JComboBox(), "Source Property");
561 sourceStepModel = new DefaultComboBoxModel();
562 sourceStepCombo = UISupport.addTooltipListener(new JComboBox(sourceStepModel),
563 "Source Step or Property Container");
564 sourceStepCombo.setRenderer(new StepComboRenderer());
565 sourcePropertyCombo.setRenderer(new PropertyComboRenderer());
566
567 componentEnabler.add(sourcePropertyCombo);
568 componentEnabler.add(sourceStepCombo);
569
570 targetPropertyCombo = UISupport.addTooltipListener(new JComboBox(), "Target Property");
571 targetStepModel = new DefaultComboBoxModel();
572 targetStepCombo = UISupport.addTooltipListener(new JComboBox(targetStepModel),
573 "Target Step or Property Container");
574 targetStepCombo.setRenderer(new StepComboRenderer());
575 targetPropertyCombo.setRenderer(new PropertyComboRenderer());
576
577 componentEnabler.add(targetPropertyCombo);
578 componentEnabler.add(targetStepCombo);
579
580 sourceStepPropertiesListener = new TestStepPropertiesListener(sourcePropertyCombo);
581 targetStepPropertiesListener = new TestStepPropertiesListener(targetPropertyCombo);
582
583 sourceStepModel.addElement(PropertyExpansionUtils.getGlobalProperties());
584 sourceStepModel.addElement(transferStep.getTestCase().getTestSuite().getProject());
585 sourceStepModel.addElement(transferStep.getTestCase().getTestSuite());
586 sourceStepModel.addElement(transferStep.getTestCase());
587
588 for (int c = 0; c < transferStep.getTestCase().getTestStepCount(); c++)
589 {
590 WsdlTestStep testStep = transferStep.getTestCase().getTestStepAt(c);
591 if (testStep == transferStep)
592 continue;
593
594 sourceStepModel.addElement(testStep);
595 }
596
597 for (int c = 0; c < sourceStepModel.getSize(); c++)
598 targetStepModel.addElement(sourceStepModel.getElementAt(c));
599
600 sourceStepCombo.setSelectedItem(null);
601 sourceStepCombo.setEnabled(false);
602 sourceStepCombo.addItemListener(new StepComboItemListener(sourcePropertyCombo, sourceStepPropertiesListener));
603 sourceStepCombo.addItemListener(new ItemListener()
604 {
605
606 public void itemStateChanged(ItemEvent e)
607 {
608 if (e.getStateChange() == ItemEvent.SELECTED && !selecting)
609 {
610 TestPropertyHolder sourceStep = (TestPropertyHolder) sourceStepCombo.getSelectedItem();
611 PropertyTransfer valueTransfer = getCurrentTransfer();
612
613 if (valueTransfer != null)
614 {
615 String name = "";
616
617 if (sourceStep == PropertyExpansionUtils.getGlobalProperties())
618 name = PropertyExpansion.GLOBAL_REFERENCE;
619 else if (sourceStep == transferStep.getTestCase().getTestSuite().getProject())
620 name = PropertyExpansion.PROJECT_REFERENCE;
621 else if (sourceStep == transferStep.getTestCase().getTestSuite())
622 name = PropertyExpansion.TESTSUITE_REFERENCE;
623 else if (sourceStep == transferStep.getTestCase())
624 name = PropertyExpansion.TESTCASE_REFERENCE;
625 else
626 name = sourceStep.getModelItem().getName();
627
628 valueTransfer.setSourceStepName(name);
629 }
630 }
631 }
632 });
633
634 toolbar.add(UISupport.setFixedSize(sourceStepCombo, 200, 21));
635 toolbar.addUnrelatedGap();
636
637 toolbar.addFixed(new JLabel("Property:"));
638 toolbar.addRelatedGap();
639
640 sourcePropertyCombo.setToolTipText("The property the value will be transferred from");
641 sourcePropertyCombo.setEnabled(false);
642 sourcePropertyCombo.addItemListener(new ItemListener()
643 {
644
645 public void itemStateChanged(ItemEvent e)
646 {
647 if (e.getStateChange() == ItemEvent.SELECTED && !selecting)
648 {
649 TestProperty sourceProperty = (TestProperty) sourcePropertyCombo.getSelectedItem();
650 PropertyTransfer valueTransfer = getCurrentTransfer();
651
652 if (valueTransfer != null)
653 {
654 valueTransfer.setSourcePropertyName(sourceProperty.getName());
655 }
656 }
657 }
658 });
659
660 toolbar.add(UISupport.setFixedSize(sourcePropertyCombo, 200, 21));
661 toolbar.addGlue();
662 return toolbar;
663 }
664
665 public PropertyTransfer getCurrentTransfer()
666 {
667 int ix = transferList.getSelectedIndex();
668 return ix == -1 ? null : transferStep.getTransferAt(ix);
669 }
670
671 /***
672 * Listen for testStep property changes and update properties combo
673 * accordingly
674 */
675
676 private final class TestStepPropertiesListener implements TestPropertyListener
677 {
678 private final JComboBox combo;
679
680 public TestStepPropertiesListener(JComboBox combo)
681 {
682 this.combo = combo;
683 }
684
685 public void propertyAdded(String name)
686 {
687 TestProperty property = combo == targetPropertyCombo ? getCurrentTransfer().getTargetStep().getProperty(name)
688 : getCurrentTransfer().getSourceStep().getProperty(name);
689
690 combo.addItem(property);
691 combo.setEnabled(true);
692 }
693
694 public void propertyRemoved(String name)
695 {
696 if (combo.getSelectedItem() != null && ((TestProperty) combo.getSelectedItem()).getName().equals(name))
697 combo.setSelectedItem(null);
698
699 for (int c = 0; c < combo.getItemCount(); c++)
700 {
701 if (((TestProperty) combo.getItemAt(c)).getName().equals(name))
702 {
703 combo.removeItemAt(c);
704 break;
705 }
706 }
707
708 combo.setEnabled(combo.getItemCount() > 0);
709 }
710
711 public void propertyRenamed(String oldName, String newName)
712 {
713 }
714
715 public void propertyValueChanged(String name, String oldValue, String newValue)
716 {
717 }
718
719 public void propertyMoved(String name, int oldIndex, int newIndex)
720 {
721 combo.removeItemAt(oldIndex);
722
723 TestProperty property = combo == targetPropertyCombo ? getCurrentTransfer().getTargetStep().getProperty(name)
724 : getCurrentTransfer().getSourceStep().getProperty(name);
725
726 combo.insertItemAt(property, newIndex);
727 }
728 }
729
730 /***
731 * Listen for teststep changes and update source/target step combos
732 * accordingly
733 */
734
735 private final class InternalTestSuiteListener extends TestSuiteListenerAdapter
736 {
737 public void testStepAdded(TestStep testStep, int index)
738 {
739 if (testStep.getTestCase() == transferStep.getTestCase())
740 {
741 sourceStepModel.addElement(testStep);
742 targetStepModel.addElement(testStep);
743 }
744 }
745
746 public void testStepMoved(TestStep testStep, int fromIndex, int offset)
747 {
748 if (testStep.getTestCase() == transferStep.getTestCase())
749 {
750 String testStepName = testStep.getName();
751 if (sourceStepModel.getIndexOf(testStepName) == fromIndex)
752 {
753 String sourceStep = (String) sourceStepCombo.getSelectedItem();
754 String sourceProperty = (String) sourcePropertyCombo.getSelectedItem();
755
756 sourceStepModel.removeElementAt(fromIndex);
757 if (fromIndex + offset > sourceStepModel.getSize())
758 sourceStepModel.addElement(testStepName);
759 else
760 sourceStepModel.insertElementAt(testStepName, fromIndex + offset);
761
762 sourceStepCombo.setSelectedItem(sourceStep);
763 sourcePropertyCombo.setSelectedItem(sourceProperty);
764 }
765
766 if (targetStepModel.getIndexOf(testStepName) == fromIndex)
767 {
768 String targetStep = (String) targetStepCombo.getSelectedItem();
769 String targetProperty = (String) targetPropertyCombo.getSelectedItem();
770
771 targetStepModel.removeElementAt(fromIndex);
772 if (fromIndex + offset > targetStepModel.getSize())
773 targetStepModel.addElement(testStepName);
774 else
775 targetStepModel.insertElementAt(testStepName, fromIndex + offset);
776
777 targetStepCombo.setSelectedItem(targetStep);
778 targetPropertyCombo.setSelectedItem(targetProperty);
779 }
780 }
781 }
782
783 public void testStepRemoved(TestStep testStep, int index)
784 {
785 if (testStep.getTestCase() == transferStep.getTestCase())
786 {
787 sourceStepModel.removeElement(testStep);
788 targetStepModel.removeElement(testStep);
789 }
790 }
791 }
792
793 /***
794 * Listen to step selections and update properties combo accordingly
795 */
796
797 private final class StepComboItemListener implements ItemListener
798 {
799 private final JComboBox propertyCombo;
800 private final TestStepPropertiesListener testStepPropertiesListener;
801
802 public StepComboItemListener(final JComboBox propertyCombo, TestStepPropertiesListener testStepPropertiesListener)
803 {
804 this.propertyCombo = propertyCombo;
805 this.testStepPropertiesListener = testStepPropertiesListener;
806 }
807
808 public void itemStateChanged(ItemEvent e)
809 {
810 if (e.getStateChange() == ItemEvent.SELECTED)
811 {
812 TestPropertyHolder selectedItem = (TestPropertyHolder) e.getItem();
813 String[] propertyNames = selectedItem.getPropertyNames();
814
815
816 if (propertyCombo == targetPropertyCombo)
817 {
818 List<String> names = new ArrayList<String>();
819 for (String name : propertyNames)
820 {
821 TestProperty property = selectedItem.getProperty(name);
822 if (property != null && !property.isReadOnly())
823 names.add(property.getName());
824 }
825
826 propertyNames = names.toArray(new String[names.size()]);
827 }
828
829 DefaultComboBoxModel model = new DefaultComboBoxModel();
830 for (String name : propertyNames)
831 model.addElement(selectedItem.getProperty(name));
832
833 propertyCombo.setModel(model);
834 propertyCombo.setEnabled(propertyNames.length > 0);
835
836 if (propertyCombo == targetPropertyCombo)
837 propertyCombo.setSelectedItem(getCurrentTransfer().getTargetProperty());
838 else
839 propertyCombo.setSelectedItem(getCurrentTransfer().getSourceProperty());
840
841 selectedItem.addTestPropertyListener(testStepPropertiesListener);
842 }
843 else
844 {
845 propertyCombo.removeAllItems();
846 propertyCombo.setEnabled(false);
847 }
848 }
849 }
850
851 /***
852 * Handle updates to source path
853 */
854
855 private final class SourceAreaDocumentListener extends DocumentListenerAdapter
856 {
857 public void update(Document document)
858 {
859 int ix = transferList.getSelectedIndex();
860 if (ix != -1)
861 {
862 transferStep.getTransferAt(ix).setSourcePath(sourceArea.getText());
863 }
864 }
865 }
866
867 /***
868 * Handle updates to target path
869 */
870
871 private final class TargetAreaDocumentListener extends DocumentListenerAdapter
872 {
873 public void update(Document document)
874 {
875 int ix = transferList.getSelectedIndex();
876 if (ix != -1)
877 {
878 transferStep.getTransferAt(ix).setTargetPath(targetArea.getText());
879 }
880 }
881 }
882
883 /***
884 * Listen to selection changes in transfer list and update controls
885 * accordingly
886 */
887
888 private final class TransferListSelectionListener implements ListSelectionListener
889 {
890 private PropertyTransfer transfer;
891
892 public void valueChanged(ListSelectionEvent e)
893 {
894 selecting = true;
895
896 if (transfer != null)
897 {
898 transfer.removePropertyChangeListener(transferPropertyChangeListener);
899 }
900
901 transfer = getCurrentTransfer();
902 setSelectedTransfer(transfer);
903 selecting = false;
904 }
905 }
906
907 private void setSelectedTransfer(PropertyTransfer transfer)
908 {
909 if (transfer == null)
910 {
911 sourceArea.setText("");
912 targetArea.setText("");
913
914 sourcePropertyCombo.removeAllItems();
915 targetPropertyCombo.removeAllItems();
916
917 sourceStepCombo.setSelectedIndex(-1);
918 targetStepCombo.setSelectedIndex(-1);
919 }
920 else
921 {
922 transfer.addPropertyChangeListener(transferPropertyChangeListener);
923
924 sourceArea.setText(transfer.getSourcePath());
925 sourceArea.setCaretPosition(0);
926 targetArea.setText(transfer.getTargetPath());
927 targetArea.setCaretPosition(0);
928
929 sourceStepCombo.setSelectedItem(transfer.getSourceStep());
930 sourcePropertyCombo.setSelectedItem(transfer.getSourceProperty());
931
932 targetStepCombo.setSelectedItem(transfer.getTargetStep());
933 targetPropertyCombo.setSelectedItem(transfer.getTargetProperty());
934
935 failTransferCheckBox.setSelected(transfer.getFailOnError());
936 setNullCheckBox.setSelected(transfer.getSetNullOnMissingSource());
937 transferTextContentCheckBox.setSelected(transfer.getTransferTextContent());
938 ignoreEmptyCheckBox.setSelected(transfer.getIgnoreEmpty());
939 transferAllCheckBox.setSelected(transfer.getTransferToAll());
940 useXQueryCheckBox.setSelected(transfer.getUseXQuery());
941 entitizeCheckBox.setSelected(transfer.getEntitize());
942 transferChildNodesCheckBox.setSelected(transfer.getTransferChildNodes());
943
944 disableButton.setSelected(transfer.isDisabled());
945 }
946
947 copyButton.setEnabled(transfer != null);
948 renameButton.setEnabled(transfer != null);
949 deleteButton.setEnabled(transfer != null);
950 disableButton.setEnabled(transfer != null);
951 declareButton.setEnabled(transfer != null);
952 sourceStepCombo.setEnabled(transfer != null);
953 targetStepCombo.setEnabled(transfer != null);
954 sourceArea.setEnabled(transfer != null);
955 targetArea.setEnabled(transfer != null);
956 failTransferCheckBox.setEnabled(transfer != null);
957 setNullCheckBox.setEnabled(transfer != null);
958 transferTextContentCheckBox.setEnabled(transfer != null);
959 ignoreEmptyCheckBox.setEnabled(transfer != null);
960 transferAllCheckBox.setEnabled(transfer != null);
961 useXQueryCheckBox.setEnabled(transfer != null);
962 entitizeCheckBox.setEnabled(transfer != null);
963 transferChildNodesCheckBox.setEnabled(transfer != null);
964
965 runAllButton.setEnabled(transferList.getModel().getSize() > 0);
966 runButton.setEnabled(transfer != null);
967
968 sourcePropertyCombo.setEnabled(transfer != null);
969 targetPropertyCombo.setEnabled(transfer != null);
970 }
971
972 /***
973 * Listen to property changes and update UI objects. These may have been
974 * triggered by UI so first check for actual difference so we dont end up in
975 * loop.
976 */
977
978 private class TransferPropertyChangeListener implements PropertyChangeListener
979 {
980 public void propertyChange(PropertyChangeEvent evt)
981 {
982 Object newValue = evt.getNewValue();
983
984 if (evt.getPropertyName().equals(PropertyTransfer.SOURCE_PATH_PROPERTY))
985 {
986 if (!sourceArea.getText().equals(newValue))
987 sourceArea.setText((String) newValue);
988 }
989 else if (evt.getPropertyName().equals(PropertyTransfer.TARGET_PATH_PROPERTY))
990 {
991 if (!targetArea.getText().equals(newValue))
992 targetArea.setText((String) newValue);
993 }
994 else if (evt.getPropertyName().equals(PropertyTransfer.SOURCE_STEP_PROPERTY))
995 {
996 Object selectedItem = sourceStepCombo.getSelectedItem();
997 if (newValue == null || selectedItem == null || !selectedItem.equals(newValue))
998 {
999 selecting = true;
1000 sourceStepCombo.setSelectedItem(newValue);
1001 selecting = false;
1002 }
1003 }
1004 else if (evt.getPropertyName().equals(PropertyTransfer.TARGET_STEP_PROPERTY))
1005 {
1006 Object selectedItem = targetStepCombo.getSelectedItem();
1007 if (newValue == null || selectedItem == null || !selectedItem.equals(newValue))
1008 {
1009 selecting = true;
1010 targetStepCombo.setSelectedItem(newValue);
1011 selecting = false;
1012 }
1013 }
1014 else if (evt.getPropertyName().equals(PropertyTransfer.SOURCE_TYPE_PROPERTY))
1015 {
1016 Object selectedItem = sourcePropertyCombo.getSelectedItem();
1017 if (selectedItem == null || !selectedItem.equals(newValue))
1018 sourcePropertyCombo.setSelectedItem(newValue);
1019 }
1020 else if (evt.getPropertyName().equals(PropertyTransfer.TARGET_TYPE_PROPERTY))
1021 {
1022 Object selectedItem = targetPropertyCombo.getSelectedItem();
1023 if (selectedItem == null || !selectedItem.equals(newValue))
1024 targetPropertyCombo.setSelectedItem(newValue);
1025 }
1026 }
1027 }
1028
1029 private final class AddAction extends AbstractAction
1030 {
1031 public AddAction()
1032 {
1033 putValue(Action.SHORT_DESCRIPTION, "Adds a new Property Transfer");
1034 putValue(Action.SMALL_ICON, UISupport.createImageIcon("/add_property.gif"));
1035 }
1036
1037 public void actionPerformed(ActionEvent e)
1038 {
1039 String name = UISupport.prompt("Specify name for value transfer", "Add Transfer", "");
1040 if (name == null || name.trim().length() == 0)
1041 return;
1042
1043 transferStep.addTransfer(name);
1044
1045 listModel.addElement(name);
1046 transferList.setSelectedIndex(listModel.getSize() - 1);
1047 }
1048 }
1049
1050 private final class CopyAction extends AbstractAction
1051 {
1052 public CopyAction()
1053 {
1054 putValue(Action.SHORT_DESCRIPTION, "Copies the selected Property Transfer");
1055 putValue(Action.SMALL_ICON, UISupport.createImageIcon("/clone_request.gif"));
1056 }
1057
1058 public void actionPerformed(ActionEvent e)
1059 {
1060 int ix = transferList.getSelectedIndex();
1061 PropertyTransfer config = transferStep.getTransferAt(ix);
1062
1063 String name = UISupport.prompt("Specify name for value transfer", "Copy Transfer", config.getName());
1064 if (name == null || name.trim().length() == 0)
1065 return;
1066
1067 PropertyTransfer transfer = transferStep.addTransfer(name);
1068 transfer.setSourceStepName(config.getSourceStepName());
1069 transfer.setSourcePropertyName(config.getSourcePropertyName());
1070 transfer.setSourcePath(config.getSourcePath());
1071 transfer.setTargetStepName(config.getTargetStepName());
1072 transfer.setTargetPropertyName(config.getTargetPropertyName());
1073 transfer.setTargetPath(config.getTargetPath());
1074
1075 listModel.addElement(name);
1076 transferList.setSelectedIndex(listModel.getSize() - 1);
1077 }
1078 }
1079
1080 private final class DeleteAction extends AbstractAction
1081 {
1082 public DeleteAction()
1083 {
1084 putValue(Action.SMALL_ICON, UISupport.createImageIcon("/remove_property.gif"));
1085 putValue(Action.SHORT_DESCRIPTION, "Deletes the selected Property Transfer");
1086 }
1087
1088 public void actionPerformed(ActionEvent e)
1089 {
1090 if (UISupport.confirm("Delete selected transfer", "Delete Transfer"))
1091 {
1092 transferList.setSelectedIndex(-1);
1093
1094 int ix = transferList.getSelectedIndex();
1095 transferStep.removeTransferAt(ix);
1096 listModel.remove(ix);
1097
1098 if (listModel.getSize() > 0)
1099 {
1100 transferList.setSelectedIndex(ix > listModel.getSize() - 1 ? listModel.getSize() - 1 : ix);
1101 }
1102 }
1103 }
1104 }
1105
1106 private final class ClearLogAction extends AbstractAction
1107 {
1108 public ClearLogAction()
1109 {
1110 putValue(Action.SMALL_ICON, UISupport.createImageIcon("/clear_properties.gif"));
1111 putValue(Action.SHORT_DESCRIPTION, "Clears the property-transfer log");
1112 }
1113
1114 public void actionPerformed(ActionEvent e)
1115 {
1116 transferLogTableModel.clear();
1117 }
1118 }
1119
1120 private final class RenameAction extends AbstractAction
1121 {
1122 public RenameAction()
1123 {
1124 putValue(Action.SMALL_ICON, UISupport.createImageIcon("/rename.gif"));
1125 putValue(Action.SHORT_DESCRIPTION, "Renames the selected Property Transfer");
1126 }
1127
1128 public void actionPerformed(ActionEvent e)
1129 {
1130 PropertyTransfer transfer = getCurrentTransfer();
1131
1132 String newName = UISupport.prompt("Specify new name for transfer", "Rename Transfer", transfer.getName());
1133
1134 if (newName != null && !transfer.getName().equals(newName))
1135 {
1136 listModel.setElementAt(newName, transferList.getSelectedIndex());
1137 transfer.setName(newName);
1138 }
1139 }
1140 }
1141
1142 private final class DisableAction extends AbstractAction
1143 {
1144 public DisableAction()
1145 {
1146 putValue(Action.SMALL_ICON, UISupport.createImageIcon("/bullet_green.png"));
1147 putValue(Action.SHORT_DESCRIPTION, "Disables the selected Property Transfer");
1148 }
1149
1150 public void actionPerformed(ActionEvent e)
1151 {
1152 PropertyTransfer transfer = getCurrentTransfer();
1153 transfer.setDisabled(disableButton.isSelected());
1154
1155 String name = transfer.getName();
1156 if (transfer.isDisabled())
1157 name += " (disabled)";
1158
1159 listModel.setElementAt(name, transferList.getSelectedIndex());
1160 }
1161 }
1162
1163 private final class DeclareNamespacesAction extends AbstractAction
1164 {
1165 public DeclareNamespacesAction()
1166 {
1167 putValue(Action.SMALL_ICON, UISupport.createImageIcon("/declareNs.gif"));
1168 putValue(Action.SHORT_DESCRIPTION,
1169 "Declare available response/request namespaces in source/target expressions");
1170 }
1171
1172 public void actionPerformed(ActionEvent e)
1173 {
1174 try
1175 {
1176 TestPropertyHolder previousStep = getCurrentTransfer().getSourceStep();
1177
1178 if (previousStep instanceof WsdlTestRequestStep)
1179 {
1180 WsdlTestRequest testRequest = ((WsdlTestRequestStep) previousStep).getTestRequest();
1181 sourceArea.setText(XmlUtils.declareXPathNamespaces(testRequest.getOperation().getInterface())
1182 + sourceArea.getText());
1183 }
1184 else
1185 UISupport.showErrorMessage("Property Source is not a Request");
1186
1187 TestPropertyHolder nextStep = getCurrentTransfer().getTargetStep();
1188
1189 if (nextStep instanceof WsdlTestRequestStep)
1190 {
1191 WsdlTestRequest testRequest = ((WsdlTestRequestStep) nextStep).getTestRequest();
1192 targetArea.setText(XmlUtils.declareXPathNamespaces(testRequest.getOperation().getInterface())
1193 + targetArea.getText());
1194 }
1195 else
1196 UISupport.showErrorMessage("Property Target is not a Request");
1197 }
1198 catch (Exception e1)
1199 {
1200 UISupport.showErrorMessage(e1);
1201 }
1202 }
1203 }
1204
1205 private final class RunAllAction extends AbstractAction
1206 {
1207 public RunAllAction()
1208 {
1209 putValue(Action.SMALL_ICON, UISupport.createImageIcon("/run_all.gif"));
1210 putValue(Action.SHORT_DESCRIPTION, "Runs all Property Transfers");
1211 }
1212
1213 public void actionPerformed(ActionEvent e)
1214 {
1215 if (listModel.getSize() == 0)
1216 {
1217 UISupport.showErrorMessage("Missing transfers!");
1218 return;
1219 }
1220
1221 MockTestRunner mockRunner = new MockTestRunner(transferStep.getTestCase());
1222 MockTestRunContext context = new MockTestRunContext(mockRunner, transferStep);
1223
1224 for (int c = 0; c < transferStep.getTransferCount(); c++)
1225 {
1226 PropertyTransfer transfer = transferStep.getTransferAt(c);
1227 PropertyTransfersTestStep.PropertyTransferResult result = (PropertyTransfersTestStep.PropertyTransferResult) transferStep
1228 .run(mockRunner, context, transfer);
1229 transferLogTableModel.addResult(result);
1230 }
1231 }
1232 }
1233
1234 private final class RunAction extends AbstractAction
1235 {
1236 public RunAction()
1237 {
1238 putValue(Action.SMALL_ICON, UISupport.createImageIcon("/run.gif"));
1239 putValue(Action.SHORT_DESCRIPTION, "Runs selected PropertyTransfer");
1240 }
1241
1242 public void actionPerformed(ActionEvent e)
1243 {
1244 if (transferList.getSelectedIndex() == -1)
1245 {
1246 UISupport.showErrorMessage("No transfer selectd!");
1247 return;
1248 }
1249
1250 MockTestRunner mockRunner = new MockTestRunner(transferStep.getTestCase());
1251 MockTestRunContext context = new MockTestRunContext(mockRunner, transferStep);
1252 PropertyTransferResult result = (PropertyTransferResult) transferStep.run(mockRunner, context,
1253 getCurrentTransfer());
1254 transferLogTableModel.addResult(result);
1255 }
1256 }
1257
1258 public boolean onClose(boolean canCancel)
1259 {
1260 super.release();
1261 transferStep.getTestCase().getTestSuite().removeTestSuiteListener(testSuiteListener);
1262 transferStep.getTestCase().removeTestRunListener(testRunListener);
1263
1264 PropertyTransfer transfer = getCurrentTransfer();
1265
1266 if (transfer != null)
1267 {
1268 transfer.removePropertyChangeListener(transferPropertyChangeListener);
1269 }
1270
1271 TestPropertyHolder item = (TestPropertyHolder) sourceStepCombo.getSelectedItem();
1272 if (item != null)
1273 {
1274 item.removeTestPropertyListener(sourceStepPropertiesListener);
1275 }
1276
1277 item = (TestPropertyHolder) targetStepCombo.getSelectedItem();
1278 if (item != null)
1279 {
1280 item.removeTestPropertyListener(targetStepPropertiesListener);
1281 }
1282
1283 componentEnabler.release();
1284 if (resultDesktopPanel != null)
1285 SoapUI.getDesktop().closeDesktopPanel(resultDesktopPanel);
1286
1287 inspectorPanel.release();
1288
1289 return true;
1290 }
1291
1292 public JComponent getComponent()
1293 {
1294 return this;
1295 }
1296
1297 protected JTextArea getSourceArea()
1298 {
1299 return sourceArea;
1300 }
1301
1302 protected JTextArea getTargetArea()
1303 {
1304 return targetArea;
1305 }
1306
1307 public boolean dependsOn(ModelItem modelItem)
1308 {
1309 return modelItem == transferStep || modelItem == transferStep.getTestCase()
1310 || modelItem == transferStep.getTestCase().getTestSuite()
1311 || modelItem == transferStep.getTestCase().getTestSuite().getProject();
1312 }
1313
1314 public boolean selectTransfer(PropertyTransfer transfer)
1315 {
1316 for (int c = 0; c < transferStep.getTransferCount(); c++)
1317 {
1318 if (transferStep.getTransferAt(c) == transfer)
1319 {
1320 transferList.setSelectedIndex(c);
1321 return true;
1322 }
1323 }
1324
1325 return false;
1326 }
1327
1328 private class TransfersTableModel extends AbstractTableModel
1329 {
1330 private List<PropertyTransfersTestStep.PropertyTransferResult> results = new ArrayList<PropertyTransfersTestStep.PropertyTransferResult>();
1331
1332 public synchronized int getRowCount()
1333 {
1334 int sum = 0;
1335 for (PropertyTransfersTestStep.PropertyTransferResult result : results)
1336 {
1337 sum += result.getTransferCount();
1338 }
1339
1340 return sum;
1341 }
1342
1343 public synchronized void clear()
1344 {
1345 results.clear();
1346 fireTableDataChanged();
1347 logInspector.setTitle("Transfer Log (0)");
1348 }
1349
1350 public void addResult(PropertyTransfersTestStep.PropertyTransferResult result)
1351 {
1352 int rowCount;
1353 synchronized (this)
1354 {
1355 rowCount = getRowCount();
1356 results.add(result);
1357 }
1358
1359 fireTableRowsInserted(rowCount, rowCount + result.getTransferCount());
1360
1361 logInspector.setTitle("Transfer Log (" + getRowCount() + ")");
1362 inspectorPanel.activate(logInspector);
1363 }
1364
1365 public int getColumnCount()
1366 {
1367 return 3;
1368 }
1369
1370 public String getColumnName(int column)
1371 {
1372 switch (column)
1373 {
1374 case 0:
1375 return "Timestamp";
1376 case 1:
1377 return "Transfer Name";
1378 case 2:
1379 return "Transferred Values";
1380 }
1381
1382 return null;
1383 }
1384
1385 public synchronized Object getValueAt(int rowIndex, int columnIndex)
1386 {
1387
1388 PropertyTransfersTestStep.PropertyTransferResult result = null;
1389 int sum = 0;
1390
1391 for (int c = 0; c < results.size(); c++)
1392 {
1393 if (sum + results.get(c).getTransferCount() > rowIndex)
1394 {
1395 result = results.get(c);
1396 break;
1397 }
1398 else
1399 {
1400 sum += results.get(c).getTransferCount();
1401 }
1402 }
1403
1404 if (result != null)
1405 {
1406 switch (columnIndex)
1407 {
1408 case 0:
1409 return new Date(result.getTimeStamp()).toString();
1410 case 1:
1411 return result.getTransferAt(rowIndex - sum).getName();
1412 case 2:
1413 return Arrays.toString(result.getTransferredValuesAt(rowIndex - sum));
1414 }
1415 }
1416
1417 return null;
1418 }
1419
1420 }
1421
1422 private class InternalTestRunListener extends TestRunListenerAdapter
1423 {
1424 @Override
1425 public void afterStep(TestCaseRunner testRunner, TestCaseRunContext runContext, TestStepResult result)
1426 {
1427 if (result.getTestStep() == transferStep)
1428 {
1429 transferLogTableModel.addResult((PropertyTransferResult) result);
1430 }
1431 }
1432 }
1433
1434 private class StepComboRenderer extends DefaultListCellRenderer
1435 {
1436 @Override
1437 public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected,
1438 boolean cellHasFocus)
1439 {
1440 Component result = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
1441
1442 if (value instanceof TestModelItem)
1443 {
1444 TestModelItem item = (TestModelItem) value;
1445 setIcon(item.getIcon());
1446 setText(item.getName());
1447 }
1448 else if (value == PropertyExpansionUtils.getGlobalProperties())
1449 {
1450 setText("Global");
1451 }
1452
1453 setToolTipText(getText());
1454
1455 return result;
1456 }
1457 }
1458
1459 private class PropertyComboRenderer extends DefaultListCellRenderer
1460 {
1461 @Override
1462 public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected,
1463 boolean cellHasFocus)
1464 {
1465 Component result = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
1466
1467 if (value != null)
1468 {
1469 TestProperty item = (TestProperty) value;
1470 setText(item.getName());
1471 }
1472
1473 setToolTipText(getText());
1474
1475 return result;
1476 }
1477 }
1478 }