From e431cdf008d67fbf885ebc5c789c0230bab2a9c9 Mon Sep 17 00:00:00 2001 From: boccioli_m Date: Wed, 16 Sep 2015 16:26:59 +0200 Subject: [PATCH] Startup --- ... - beofre-fixing-parallelise-one-test.java | 2085 +++++++++++++++++ 1 file changed, 2085 insertions(+) create mode 100644 plugins/TestingList - beofre-fixing-parallelise-one-test.java diff --git a/plugins/TestingList - beofre-fixing-parallelise-one-test.java b/plugins/TestingList - beofre-fixing-parallelise-one-test.java new file mode 100644 index 0000000..0eed41c --- /dev/null +++ b/plugins/TestingList - beofre-fixing-parallelise-one-test.java @@ -0,0 +1,2085 @@ +/* + * Copyright (c) 2015 Paul Scherrer Institute. All rights reserved. + */ +// + +import ch.psi.pshell.core.Controller; +import ch.psi.pshell.scripting.StatementException; +import ch.psi.pshell.security.AccessLevel; +import ch.psi.pshell.ui.App; +import ch.psi.pshell.ui.Panel; +import ch.psi.pshell.ui.Plugin; +import ch.psi.pshell.ui.View; +import ch.psi.utils.swing.SwingUtils; +import ch.psi.wsaf.Task; +import java.awt.Point; +import java.io.File; +import java.text.DateFormat; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.HashMap; +import java.util.logging.Level; +import java.util.logging.Logger; +import javax.swing.ImageIcon; +import javax.swing.JPanel; +import javax.swing.table.DefaultTableModel; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.lang.reflect.InvocationTargetException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.Vector; +import java.util.function.Consumer; +import java.util.logging.FileHandler; +import java.util.logging.SimpleFormatter; +import java.util.regex.PatternSyntaxException; +import javax.script.ScriptException; +import javax.swing.DefaultCellEditor; +import javax.swing.JComboBox; +import javax.swing.JDialog; +import javax.swing.JFileChooser; +import javax.swing.JMenuItem; +import javax.swing.RowFilter; +import javax.swing.filechooser.FileSystemView; +import javax.swing.table.DefaultTableCellRenderer; +import javax.swing.table.TableModel; +import javax.swing.table.TableRowSorter; +import org.apache.commons.io.FilenameUtils; +import org.python.core.PyList; +import static org.python.bouncycastle.util.Arrays.append; + +// + +/** + * + * @author boccioli_m + */ +public class TestingList extends Panel { + + Task task = new Task() { + @Override + protected Object execute() throws Exception { + return true; + } + }; + + public TestingList() throws Exception { + initialise(); + } + + /** + * enumeration of table column indexes + */ + public enum COL { + + CHECK(0), + STARTSEQUENCE(1), + TIME(2), + DEVICENAME(3), + DEVICEDESCR(4), + TESTSUITE(5), + TESTNAME(6), + TESTPATH(7), + TESTPARAMS(8), + TESTDESCR(9), + TESTHELP(10), + RESULT(11), + STATUS(12), + ICON(13); + private int value; + + private COL(int value) { + this.value = value; + } + + /** + * + * @return int index of the corresponding column + */ + public int index() { + return (int) value; + } + }; + + /** + * enumeration of possible test statuses: text and related icon + */ + public enum TestStatus { + + SUCCESS, + FAILURE, + PENDING, + DISABLED, + RUNNING; + + /** + * + * @return + */ + public String IconFilename() { + String iconFileName = ""; + switch (this) { + case SUCCESS: + iconFileName = "/icons/button_ok-16px.png"; + break; + case FAILURE: + iconFileName = "/icons/button_close-16px.png"; + break; + case PENDING: + iconFileName = "/icons/button_stop-16px.png"; + break; + case DISABLED: + iconFileName = ""; + break; + case RUNNING: + iconFileName = "/icons/button_play-16px.png"; + break; + } + return iconFileName; + } + + @Override + public final String toString() { + String status = ""; + switch (this) { + case SUCCESS: + status = "Success"; + break; + case FAILURE: + status = "Failure"; + break; + case PENDING: + status = "Pending"; + break; + case DISABLED: + status = "Disabled"; + break; + case RUNNING: + status = "Running"; + break; + } + return status; + } + + /** + * + * @return ImageIcon corresponding to the selected testStatus + */ + public ImageIcon Icon() { + String iconFileName = this.IconFilename(); + ImageIcon icon = null; + if (iconFileName != "") { + icon = new ImageIcon(getClass().getResource(this.IconFilename())); + } + return icon; + } + }; + + /** + * Sequence options: AFTER: the test starts after the test above has + * finished TOGETHER: the test starts at the same time as the test above + */ + public enum StartSequence { + + AFTER, + TOGETHER; + + @Override + public final String toString() { + String status = ""; + switch (this) { + case AFTER: + status = "After previous"; + break; + case TOGETHER: + status = "With previous"; + break; + } + return status; + } + }; + + /** + * List of Keys defining the arguments to be passed to a test script + */ + public enum testArgNames { + + PARAMETERS, + TEST, + DEVICE, + TEST_PATH, + STATUS; + + @Override + public final String toString() { + String status = ""; + switch (this) { + case PARAMETERS: + status = "parameters"; + break; + case TEST: + status = "test"; + break; + case DEVICE: + status = "device"; + break; + case TEST_PATH: + status = "testPath"; + break; + case STATUS: + status = "status"; + break; + } + return status; + } + }; + + /** + * List of Keys defining the arguments to be passed to a test script + */ + public enum testPropertyNames { + + DEVICE_NAME, + DEVICE_DESCRIPTION, + TEST_NAME, + TEST_DESCRIPTION, + TEST_PARAMETERS, + TEST_HELP; + + @Override + public final String toString() { + String val = ""; + switch (this) { + case DEVICE_NAME: + case TEST_NAME: + val = "name"; + break; + case TEST_PARAMETERS: + val = "parameters"; + break; + case DEVICE_DESCRIPTION: + case TEST_DESCRIPTION: + val = "description"; + break; + case TEST_HELP: + val = "help"; + break; + } + return val; + } + }; + + Logger logger = Logger.getLogger("TestsLog"); + //these paths are converted to unix or win path according to host OS + public static Path TESTS_DEVICES_DEFAULT_DIR = Paths.get(".", "home", "script", "tests", "devices"); + public static Path TESTS_TESTS_DEFAULT_DIR = Paths.get(".", "home", "script", "tests", "tests"); + public static Path TESTS_CONFIG_DEFAULT_DIR = Paths.get(".", "home", "script", "tests", "config"); + public final Path TESTS_LOG_DEFAULT_DIR = Paths.get(".", "home", "script", "tests", "log", "TestsLog" + getnow() + ".txt"); + public static String TESTS_CONFIG_FILENAME = ".config"; + public static String TESTS_HELP_FILENAME = "help.html"; + + /** + * initialise panel + */ + private void initialise(){ + initComponents(); + initLogger(); + buildTable(); + try { + loadTests(); + //if not administrator, then show only enabled tests + boolean bShow = Controller.getInstance().getLevel()==AccessLevel.administrator; + showSelectedTestsOnly(bShow); + jCheckBoxMenuShowSelectedTests1.setState(bShow); + if(bShow){ + //if tests are not shown, then show the load tests dialog + loadSettings(); + } + } catch (Exception ex) { + getLogger().severe(ex.getMessage()); + } + } + /** + * write info into a log file + * @param text the info to be logged + */ + private void log(Object text) { + try { + getController().getDataManager().appendLog(String.valueOf(text)); + } catch (IOException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } + } + + /** + * initialise the logger + */ + private void initLogger() { + /* + this.evalAsync("bla").handle((ok, ex) -> { + if (ex != null) { + + } else { + } + return ok; + }); + */ + + try { + + FileHandler fh; + // This block configure the logger with handler and formatter + fh = new FileHandler(TESTS_LOG_DEFAULT_DIR.toString()); + logger.addHandler(fh); + SimpleFormatter formatter = new SimpleFormatter(); + fh.setFormatter(formatter); + log("INFO - " + "New testing session"); + } catch (SecurityException e) { + SwingUtils.showMessage(this, "initLogger()", e.toString()); + } catch (IOException e) { + SwingUtils.showMessage(this, "initLogger()", e.toString()); + } + } + + /** + * + * @throws IOException + */ + @SuppressWarnings("unchecked") + + // //GEN-BEGIN:initComponents + private void initComponents() { + + jPopupMenuOptions = new javax.swing.JPopupMenu(); + jCheckBoxMenuShowSelectedTests = new javax.swing.JCheckBoxMenuItem(); + jMenuItemReload = new javax.swing.JMenuItem(); + jSeparator1 = new javax.swing.JPopupMenu.Separator(); + jMenuAdvanced = new javax.swing.JMenu(); + jMenuItemNewTest = new javax.swing.JMenuItem(); + jMenuItemNewDevice = new javax.swing.JMenuItem(); + jSeparator2 = new javax.swing.JPopupMenu.Separator(); + jMenuItemEditScript = new javax.swing.JMenuItem(); + jMenuItemOpenLog = new javax.swing.JMenuItem(); + jPopupMenuConfigs = new javax.swing.JPopupMenu(); + jPopupMenuTable = new javax.swing.JPopupMenu(); + jMenuItemShowDetails = new javax.swing.JMenuItem(); + jSeparator3 = new javax.swing.JPopupMenu.Separator(); + jMenuSelect = new javax.swing.JMenu(); + jMenuItemSelectAll = new javax.swing.JMenuItem(); + jMenuItemSelectNone = new javax.swing.JMenuItem(); + jMenuItemSelectSelection = new javax.swing.JMenuItem(); + jMenuItemDeselectSelection = new javax.swing.JMenuItem(); + jSeparator4 = new javax.swing.JPopupMenu.Separator(); + jCheckBoxMenuShowSelectedTests1 = new javax.swing.JCheckBoxMenuItem(); + jMenuItemReload1 = new javax.swing.JMenuItem(); + jScrollPane2 = new javax.swing.JScrollPane(); + jTable1 = new javax.swing.JTable(); + jPanel1 = new javax.swing.JPanel(); + jButtonRun = new javax.swing.JButton(); + jPanelButtons = new javax.swing.JPanel(); + jButtonOptions = new javax.swing.JButton(); + jButtonSave = new javax.swing.JButton(); + jButtonOpen = new javax.swing.JButton(); + jPanel2 = new javax.swing.JPanel(); + jCheckBoxEnableDisable = new javax.swing.JCheckBox(); + jButtonMoveDown = new javax.swing.JButton(); + jButtonMoveUp = new javax.swing.JButton(); + + jCheckBoxMenuShowSelectedTests.setSelected(true); + jCheckBoxMenuShowSelectedTests.setText("Show enabled tests only"); + jCheckBoxMenuShowSelectedTests.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jCheckBoxMenuShowSelectedTestsActionPerformed(evt); + } + }); + jPopupMenuOptions.add(jCheckBoxMenuShowSelectedTests); + + jMenuItemReload.setText("Reload tests"); + jMenuItemReload.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jMenuItemReloadActionPerformed(evt); + } + }); + jPopupMenuOptions.add(jMenuItemReload); + jPopupMenuOptions.add(jSeparator1); + + jMenuAdvanced.setText("Advanced"); + + jMenuItemNewTest.setText("New Test..."); + jMenuItemNewTest.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jMenuItemNewTestActionPerformed(evt); + } + }); + jMenuAdvanced.add(jMenuItemNewTest); + + jMenuItemNewDevice.setText("New Device..."); + jMenuItemNewDevice.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jMenuItemNewDeviceActionPerformed(evt); + } + }); + jMenuAdvanced.add(jMenuItemNewDevice); + jMenuAdvanced.add(jSeparator2); + + jMenuItemEditScript.setText("Edit selected test"); + jMenuItemEditScript.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jMenuItemEditScriptActionPerformed(evt); + } + }); + jMenuAdvanced.add(jMenuItemEditScript); + + jMenuItemOpenLog.setText("Open Log"); + jMenuItemOpenLog.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jMenuItemOpenLogActionPerformed(evt); + } + }); + jMenuAdvanced.add(jMenuItemOpenLog); + + jPopupMenuOptions.add(jMenuAdvanced); + + jMenuItemShowDetails.setText("Open Test Details"); + jMenuItemShowDetails.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jMenuItemShowDetailsActionPerformed(evt); + } + }); + jPopupMenuTable.add(jMenuItemShowDetails); + jPopupMenuTable.add(jSeparator3); + + jMenuSelect.setText("Enable/Disable"); + + jMenuItemSelectAll.setText("Enable all"); + jMenuItemSelectAll.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jMenuItemSelectAllActionPerformed(evt); + } + }); + jMenuSelect.add(jMenuItemSelectAll); + + jMenuItemSelectNone.setText("Disable all"); + jMenuItemSelectNone.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jMenuItemSelectNoneActionPerformed(evt); + } + }); + jMenuSelect.add(jMenuItemSelectNone); + + jMenuItemSelectSelection.setText("Enable selection"); + jMenuItemSelectSelection.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jMenuItemSelectSelectionActionPerformed(evt); + } + }); + jMenuSelect.add(jMenuItemSelectSelection); + + jMenuItemDeselectSelection.setText("Disable selection"); + jMenuItemDeselectSelection.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jMenuItemDeselectSelectionActionPerformed(evt); + } + }); + jMenuSelect.add(jMenuItemDeselectSelection); + + jPopupMenuTable.add(jMenuSelect); + jPopupMenuTable.add(jSeparator4); + + jCheckBoxMenuShowSelectedTests1.setText("Show enabled tests only"); + jCheckBoxMenuShowSelectedTests1.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jCheckBoxMenuShowSelectedTests1ActionPerformed(evt); + } + }); + jPopupMenuTable.add(jCheckBoxMenuShowSelectedTests1); + + jMenuItemReload1.setText("Reload tests"); + jMenuItemReload1.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jMenuItemReload1ActionPerformed(evt); + } + }); + jPopupMenuTable.add(jMenuItemReload1); + + setLayout(new java.awt.BorderLayout()); + + jTable1.setAutoCreateRowSorter(true); + jTable1.setFont(new java.awt.Font("Tahoma", 0, 15)); // NOI18N + jTable1.setModel(new javax.swing.table.DefaultTableModel( + new Object [][] { + + }, + new String [] { + "Enable", "Start", "Time", "Device Name", "Device Description", "Test Suite", "Test Name", "Test Peth", "Test Parameters", "Test Description", "Test Help", "Last Test Result", "Status", "" + } + ) { + Class[] types = new Class [] { + java.lang.Boolean.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, javax.swing.Icon.class + }; + boolean[] canEdit = new boolean [] { + true, true, false, false, false, false, false, false, false, false, false, false, false, false + }; + + public Class getColumnClass(int columnIndex) { + return types [columnIndex]; + } + + public boolean isCellEditable(int rowIndex, int columnIndex) { + return canEdit [columnIndex]; + } + }); + jTable1.getTableHeader().setReorderingAllowed(false); + jTable1.setDragEnabled(true); + jTable1.setRowHeight(22); + jTable1.addMouseListener(new java.awt.event.MouseAdapter() { + public void mouseClicked(java.awt.event.MouseEvent evt) { + jTable1MouseClicked(evt); + } + }); + jTable1.addKeyListener(new java.awt.event.KeyAdapter() { + public void keyReleased(java.awt.event.KeyEvent evt) { + jTable1KeyReleased(evt); + } + }); + jScrollPane2.setViewportView(jTable1); + + add(jScrollPane2, java.awt.BorderLayout.CENTER); + + jPanel1.setMinimumSize(new java.awt.Dimension(100, 100)); + jPanel1.setPreferredSize(new java.awt.Dimension(110, 110)); + jPanel1.setLayout(new java.awt.BorderLayout()); + + jButtonRun.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/play-circled-64-000000.png"))); // NOI18N + jButtonRun.setToolTipText("Run enabled tests"); + jButtonRun.setMaximumSize(new java.awt.Dimension(330000, 39)); + jButtonRun.setMinimumSize(new java.awt.Dimension(90, 90)); + jButtonRun.setPreferredSize(new java.awt.Dimension(90, 39)); + jButtonRun.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jButtonRunActionPerformed(evt); + } + }); + jPanel1.add(jButtonRun, java.awt.BorderLayout.CENTER); + + jPanelButtons.setMinimumSize(new java.awt.Dimension(0, 80)); + jPanelButtons.setPreferredSize(new java.awt.Dimension(100, 80)); + jPanelButtons.setLayout(new java.awt.BorderLayout()); + + jButtonOptions.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/settings-32px.png"))); // NOI18N + jButtonOptions.setToolTipText("Optional actions"); + jButtonOptions.setMaximumSize(new java.awt.Dimension(60, 40)); + jButtonOptions.setMinimumSize(new java.awt.Dimension(0, 40)); + jButtonOptions.setPreferredSize(new java.awt.Dimension(50, 40)); + jButtonOptions.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jButtonOptionsActionPerformed(evt); + } + }); + jPanelButtons.add(jButtonOptions, java.awt.BorderLayout.LINE_START); + + jButtonSave.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/android-save-24-000000.png"))); // NOI18N + jButtonSave.setToolTipText("Save current configuration"); + jButtonSave.setMaximumSize(new java.awt.Dimension(60, 40)); + jButtonSave.setMinimumSize(new java.awt.Dimension(0, 40)); + jButtonSave.setPreferredSize(new java.awt.Dimension(50, 40)); + jButtonSave.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jButtonSaveActionPerformed(evt); + } + }); + jPanelButtons.add(jButtonSave, java.awt.BorderLayout.LINE_END); + + jButtonOpen.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/folder-open-24-000000.png"))); // NOI18N + jButtonOpen.setToolTipText("Open configuration"); + jButtonOpen.setMinimumSize(new java.awt.Dimension(0, 9)); + jButtonOpen.setPreferredSize(new java.awt.Dimension(33, 50)); + jButtonOpen.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jButtonOpenActionPerformed(evt); + } + }); + jPanelButtons.add(jButtonOpen, java.awt.BorderLayout.PAGE_END); + + jPanel1.add(jPanelButtons, java.awt.BorderLayout.EAST); + + jPanel2.setLayout(new java.awt.BorderLayout()); + + jCheckBoxEnableDisable.setToolTipText("Enable/Disable the selected tests"); + jCheckBoxEnableDisable.setHorizontalAlignment(javax.swing.SwingConstants.CENTER); + jCheckBoxEnableDisable.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER); + jCheckBoxEnableDisable.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jCheckBoxEnableDisableActionPerformed(evt); + } + }); + jPanel2.add(jCheckBoxEnableDisable, java.awt.BorderLayout.WEST); + + jButtonMoveDown.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/chevron-down-16-000000.png"))); // NOI18N + jButtonMoveDown.setToolTipText("Move the selected tests down"); + jButtonMoveDown.setMaximumSize(new java.awt.Dimension(25, 25)); + jButtonMoveDown.setMinimumSize(new java.awt.Dimension(25, 25)); + jButtonMoveDown.setPreferredSize(new java.awt.Dimension(25, 25)); + jButtonMoveDown.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jButtonMoveDownActionPerformed(evt); + } + }); + jPanel2.add(jButtonMoveDown, java.awt.BorderLayout.SOUTH); + + jButtonMoveUp.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/chevron-up-16-000000.png"))); // NOI18N + jButtonMoveUp.setToolTipText("Move the selected tests up"); + jButtonMoveUp.setMaximumSize(new java.awt.Dimension(25, 25)); + jButtonMoveUp.setMinimumSize(new java.awt.Dimension(25, 25)); + jButtonMoveUp.setPreferredSize(new java.awt.Dimension(25, 25)); + jButtonMoveUp.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + jButtonMoveUpActionPerformed(evt); + } + }); + jPanel2.add(jButtonMoveUp, java.awt.BorderLayout.PAGE_START); + + jPanel1.add(jPanel2, java.awt.BorderLayout.LINE_START); + + add(jPanel1, java.awt.BorderLayout.NORTH); + }// //GEN-END:initComponents + + private void jButtonRunActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonRunActionPerformed + if (this.jButtonRun.getToolTipText().equals("Run enabled tests")) { + setButtonToStart(); + updateStatus(); + executeTests(); + } else { + setToStopped(); + } + }//GEN-LAST:event_jButtonRunActionPerformed + + /** + * reaction to Stop + */ + private void setButtonToStop() { + abort(); + this.jButtonRun.setToolTipText("Run enabled tests"); + jButtonRun.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/play-circled-64-000000.png"))); + this.jTable1.setEnabled(true); + this.jButtonOpen.setEnabled(true); + this.jButtonOptions.setEnabled(true); + this.jButtonSave.setEnabled(true); + } + + /** + * reaction to Start + */ + private void setButtonToStart() { + this.jButtonRun.setToolTipText("Stop tests"); + jButtonRun.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/stop-circled-64-000000.png"))); + this.jTable1.clearSelection(); + this.jTable1.setEnabled(false); + this.jButtonOpen.setEnabled(false); + this.jButtonOptions.setEnabled(false); + this.jButtonSave.setEnabled(false); + } + + /** + * enable/disable the tests in the table. + * + * @param bEnable if true, enable. Else, disable + * @param onlyIfSelected if true, only the tests with Selected checkbox full will be enables/disabled. + * If false, all tests will be enabled/disabled + * @param smartEnable if true, it enables/disables selected tests or, if none selected, it enables/disables all + */ + private void enableAll(boolean bEnable, boolean onlyIfSelected, boolean smartEnable){ + int iSelRows = jTable1.getSelectedRowCount(); + + if (onlyIfSelected || (smartEnable && iSelRows > 0)) {// if some rows are selected, check/uncheck selected rows + for (int row = 0; row <= jTable1.getRowCount() - 1; row++) { + for (int selRow = 0; selRow <= jTable1.getSelectedRowCount() - 1; selRow++) { + if (row == jTable1.getSelectedRows()[selRow]) { + jTable1.setValueAt(bEnable, row, 0); + } + } + } + } else {//if none of the rows are selected, check/uncheck all + for (int row = 0; row <= jTable1.getRowCount() - 1; row++) { + jTable1.setValueAt(bEnable, row, 0); + } + } + updateStatus(); + } + + private void enableAll(boolean bEnable){ + enableAll(bEnable, false, false); + } + + private void enableSelection(boolean bEnable){ + enableAll(bEnable, true, true); + } + + private void jCheckBoxEnableDisableActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jCheckBoxEnableDisableActionPerformed + enableAll(jCheckBoxEnableDisable.isSelected(), false, true); + }//GEN-LAST:event_jCheckBoxEnableDisableActionPerformed + + private void jTable1MouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_jTable1MouseClicked + if (this.jTable1.isEnabled()) { + if(evt.getButton() == java.awt.event.MouseEvent.BUTTON3){ + //right mouse click + //select row with right-click only if previously only one or zero rows were selected + if(jTable1.getSelectedRowCount()<2){ + Point cursor = evt.getPoint(); + int rowAtPoint = jTable1.rowAtPoint(cursor); + jTable1.setRowSelectionInterval(rowAtPoint, rowAtPoint); + } + //enable action Show Test Details only if one row is selected + this.jMenuItemShowDetails.setEnabled(jTable1.getSelectedRows().length == 1); + jPopupMenuTable.show(jTable1, evt.getX(), evt.getY()); + } + else{ + //left mouse click + try { + switch (evt.getClickCount()) { + case 1: + break; + case 2: + openDetails(); + break; + } + updateStatus(); + } catch (Exception ex) { + SwingUtils.showException(this, ex); + } + } + } + }//GEN-LAST:event_jTable1MouseClicked + + private void jTable1KeyReleased(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_jTable1KeyReleased + updateStatus(); + }//GEN-LAST:event_jTable1KeyReleased + + private void jButtonMoveDownActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonMoveDownActionPerformed + moveDown(); + }//GEN-LAST:event_jButtonMoveDownActionPerformed + + private void jButtonMoveUpActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonMoveUpActionPerformed + moveUp(); + }//GEN-LAST:event_jButtonMoveUpActionPerformed + + private void jButtonOpenActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonOpenActionPerformed + this.loadSettings(); + //this below is a test that can be useful to check that multithreading does work fine with passing variables + /* new Thread(() -> { + try { + //Object ret = eval("parallelize((run,('testLocalVar1',globals(),{'a':'21', 'b':34})), (run,('testLocalVar2',globals(),{'a':231, 'b':234})))"); + Object ret; + ret = eval("parallelize((run,('dummy',)))"); + ret = eval("parallelize((run,('testLocalVar1', None,{'a':21, 'b':34})), (run,('testLocalVar2', None, {'a':231, 'b':234})))"); + Object ret1 = ((ArrayList) ret).get(0); + Object ret2 = ((ArrayList) ret).get(1); + System.out.println(String.valueOf(ret1)); + System.out.println(String.valueOf(ret2)); + } catch (Exception ex) { + SwingUtils.showException(this, ex); + } + }).start(); + */ + }//GEN-LAST:event_jButtonOpenActionPerformed + + private void jButtonSaveActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonSaveActionPerformed + saveSettings(); + }//GEN-LAST:event_jButtonSaveActionPerformed + + private void jButtonOptionsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonOptionsActionPerformed + //enable some menu items only for administrator access control level + this.jMenuItemEditScript.setEnabled(Controller.getInstance().getLevel()==AccessLevel.administrator); + this.jMenuItemNewTest.setEnabled(Controller.getInstance().getLevel()==AccessLevel.administrator); + this.jMenuItemNewDevice.setEnabled(Controller.getInstance().getLevel()==AccessLevel.administrator); + jPopupMenuOptions.show(jButtonOptions, 0, jButtonOptions.getHeight()); + }//GEN-LAST:event_jButtonOptionsActionPerformed + + private void jCheckBoxMenuShowSelectedTestsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jCheckBoxMenuShowSelectedTestsActionPerformed + // TODO add your handling code here: + boolean bShow = jCheckBoxMenuShowSelectedTests.getState(); + showSelectedTestsOnly(bShow); + jCheckBoxMenuShowSelectedTests1.setState(bShow); + }//GEN-LAST:event_jCheckBoxMenuShowSelectedTestsActionPerformed + + private void jMenuItemOpenLogActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItemOpenLogActionPerformed + // TODO add your handling code here: + String cmd; + if (System.getProperty("os.name").toLowerCase().contains("windows")) { + cmd = "notepad.exe " + TESTS_LOG_DEFAULT_DIR; + } else { + cmd = "nedit " + TESTS_LOG_DEFAULT_DIR; + } + try { + Runtime.getRuntime().exec(cmd); + } catch (IOException ex) { + SwingUtils.showMessage(this, "jButtonOpenLogActionPerformed()", "jButtonOpenLogActionPerformed() " + ex.toString() + + " \nPlease open the file manually. \nFile dir: " + TESTS_LOG_DEFAULT_DIR); + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } + }//GEN-LAST:event_jMenuItemOpenLogActionPerformed + + private void jMenuItemReloadActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItemReloadActionPerformed + // TODO add your handling code here: + reloadTests(); + try { + cleanTests(); + cleanTests(); + } catch (IOException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } + }//GEN-LAST:event_jMenuItemReloadActionPerformed + + private void jMenuItemNewTestActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItemNewTestActionPerformed + // TODO add your handling code here: + openNewTestEditor("Test"); + }//GEN-LAST:event_jMenuItemNewTestActionPerformed + + private void jMenuItemNewDeviceActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItemNewDeviceActionPerformed + // TODO add your handling code here: + openNewTestEditor("Device"); + }//GEN-LAST:event_jMenuItemNewDeviceActionPerformed + + private void jCheckBoxMenuShowSelectedTests1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jCheckBoxMenuShowSelectedTests1ActionPerformed + // TODO add your handling code here: + boolean bShow = jCheckBoxMenuShowSelectedTests1.getState(); + showSelectedTestsOnly(bShow); + jCheckBoxMenuShowSelectedTests.setState(bShow); + }//GEN-LAST:event_jCheckBoxMenuShowSelectedTests1ActionPerformed + + private void jMenuItemReload1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItemReload1ActionPerformed + // TODO add your handling code here: + reloadTests(); + try { + cleanTests(); + cleanTests(); + } catch (IOException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } + }//GEN-LAST:event_jMenuItemReload1ActionPerformed + + private void jMenuItemShowDetailsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItemShowDetailsActionPerformed + try { + // TODO add your handling code here: + openDetails(); + } catch (Exception ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } + }//GEN-LAST:event_jMenuItemShowDetailsActionPerformed + + private void jMenuItemSelectAllActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItemSelectAllActionPerformed + // TODO add your handling code here: + enableAll(true); + }//GEN-LAST:event_jMenuItemSelectAllActionPerformed + + private void jMenuItemSelectNoneActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItemSelectNoneActionPerformed + // TODO add your handling code here: + enableAll(false); + }//GEN-LAST:event_jMenuItemSelectNoneActionPerformed + + private void jMenuItemSelectSelectionActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItemSelectSelectionActionPerformed + // TODO add your handling code here: + enableSelection(true); + }//GEN-LAST:event_jMenuItemSelectSelectionActionPerformed + + private void jMenuItemDeselectSelectionActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItemDeselectSelectionActionPerformed + // TODO add your handling code here: + enableSelection(false); + }//GEN-LAST:event_jMenuItemDeselectSelectionActionPerformed + + private void jMenuItemEditScriptActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItemEditScriptActionPerformed + // TODO add your handling code here: + int rows[] = jTable1.getSelectedRows(); + for(int row=0 ; row + // Variables declaration - do not modify//GEN-BEGIN:variables + private javax.swing.JButton jButtonMoveDown; + private javax.swing.JButton jButtonMoveUp; + private javax.swing.JButton jButtonOpen; + private javax.swing.JButton jButtonOptions; + private javax.swing.JButton jButtonRun; + private javax.swing.JButton jButtonSave; + private javax.swing.JCheckBox jCheckBoxEnableDisable; + private javax.swing.JCheckBoxMenuItem jCheckBoxMenuShowSelectedTests; + private javax.swing.JCheckBoxMenuItem jCheckBoxMenuShowSelectedTests1; + private javax.swing.JMenu jMenuAdvanced; + private javax.swing.JMenuItem jMenuItemDeselectSelection; + private javax.swing.JMenuItem jMenuItemEditScript; + private javax.swing.JMenuItem jMenuItemNewDevice; + private javax.swing.JMenuItem jMenuItemNewTest; + private javax.swing.JMenuItem jMenuItemOpenLog; + private javax.swing.JMenuItem jMenuItemReload; + private javax.swing.JMenuItem jMenuItemReload1; + private javax.swing.JMenuItem jMenuItemSelectAll; + private javax.swing.JMenuItem jMenuItemSelectNone; + private javax.swing.JMenuItem jMenuItemSelectSelection; + private javax.swing.JMenuItem jMenuItemShowDetails; + private javax.swing.JMenu jMenuSelect; + private javax.swing.JPanel jPanel1; + private javax.swing.JPanel jPanel2; + private javax.swing.JPanel jPanelButtons; + private javax.swing.JPopupMenu jPopupMenuConfigs; + private javax.swing.JPopupMenu jPopupMenuOptions; + private javax.swing.JPopupMenu jPopupMenuTable; + private javax.swing.JScrollPane jScrollPane2; + private javax.swing.JPopupMenu.Separator jSeparator1; + private javax.swing.JPopupMenu.Separator jSeparator2; + private javax.swing.JPopupMenu.Separator jSeparator3; + private javax.swing.JPopupMenu.Separator jSeparator4; + private javax.swing.JTable jTable1; + // End of variables declaration//GEN-END:variables + // + + /** + * reload tests from files + */ + public void reloadTests() { + try { + loadTests(); + } catch (IOException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } + } + + /** + * filter table: show only rows selected (checkbox checked) for running. + * + * @param show if false, show all tests. If true, show only selected tests. + */ + public void showSelectedTestsOnly(boolean show) { + if (show) { + filterTests("true"); + } else { + filterTests(""); + } + //if only enabled tests are visible, disable the move buttons + this.jButtonMoveUp.setEnabled(!show); + this.jButtonMoveDown.setEnabled(!show); + } + + /** + * open New Test/Device editor panel + * + * @param type can be "Device" or "Test". Either device or test will be created. + */ + public void openNewTestEditor(String type){ + try { + JDialog dlg = new JDialog(getView(), "New "+ type, true); + //create a class to visualise the details panel + Class testingListDetailsClass = getController().getClassByName("NewTest"); + JPanel detailsPanel = (JPanel) testingListDetailsClass.getConstructor(new Class[]{String.class}).newInstance(new Object[]{type}); + dlg.getContentPane().add(detailsPanel); + dlg.pack(); + dlg.setVisible(true); + } catch (ClassNotFoundException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } catch (NoSuchMethodException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } catch (SecurityException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } catch (InstantiationException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } catch (IllegalAccessException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } catch (IllegalArgumentException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } catch (InvocationTargetException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } + } + + /** + * filter table: show only rows containing the specified text. + * + * @param filterText text for filtering; can be a regex pattern. + */ + private void filterTests(String filterText) { + TableModel model = new DefaultTableModel() { + public Class getColumnClass(int column) { + Class returnValue; + if ((column >= 0) && (column < getColumnCount())) { + returnValue = getValueAt(0, column).getClass(); + } else { + returnValue = Object.class; + } + return returnValue; + } + }; + model = jTable1.getModel(); + + final TableRowSorter sorter = new TableRowSorter(model); + jTable1.setRowSorter(sorter); + if (filterText.length() == 0) { + sorter.setRowFilter(null); + } else { + try { + sorter.setRowFilter(RowFilter.regexFilter(filterText)); + } catch (PatternSyntaxException pse) { + System.err.println("Bad regex pattern"); + } + } + } + + /** + * return whether or not the tests can run (Run launched by the user) + * + * @return status of run button. True = tests launching sequence is running + */ + public boolean isTestRunAllowed() { + return (this.jButtonRun.getToolTipText().equals("Stop tests") && pendingTestsCount() > 0); + } + + /** + * move selected rows up in table + */ + private void moveUp() { + DefaultTableModel model = (DefaultTableModel) jTable1.getModel(); + int[] rows = jTable1.getSelectedRows(); + try{ + if (rows[0] - 1 >= 0) { + jTable1.setAutoCreateRowSorter(false); + model.moveRow(rows[0], rows[rows.length - 1], rows[0] - 1); + jTable1.setAutoCreateRowSorter(true); + jTable1.setRowSelectionInterval(rows[0] - 1, rows[rows.length - 1] - 1); + } + } + catch(Exception ex){ + //fail silently + } + } + + /** + * move selected rows down in table + */ + private void moveDown() { + DefaultTableModel model = (DefaultTableModel) jTable1.getModel(); + int[] rows = jTable1.getSelectedRows(); + try{ + if (rows[rows.length - 1] < jTable1.getRowCount()) { + jTable1.setAutoCreateRowSorter(false); + model.moveRow(rows[0], rows[rows.length - 1], rows[0] + 1); + jTable1.setAutoCreateRowSorter(true); + jTable1.setRowSelectionInterval(rows[0] + 1, rows[rows.length - 1] + 1); + } + } + catch(Exception ex){ + //fail silently + } + } + + /** + * open details of the selected row in a new panel + * + * @throws exception + */ + private void openDetails() throws Exception { + //pick details from the clicked row + int row = jTable1.getSelectedRow(); + String sDeviceName = jTable1.getValueAt(row, COL.DEVICENAME.ordinal()).toString(); + String sTestName = jTable1.getValueAt(row, COL.TESTNAME.ordinal()).toString(); + String sTestPath = String.valueOf(jTable1.getValueAt(row, COL.TESTPATH.ordinal())); + String sTestCaseName = jTable1.getValueAt(row, COL.TESTSUITE.ordinal()).toString(); + String sTestDescription = getTestDescription(sTestPath); + String sDeviceDescription = jTable1.getValueAt(row, COL.DEVICEDESCR.ordinal()).toString(); + String sLastResult = jTable1.getValueAt(row, COL.RESULT.ordinal()).toString(); + String sResultTime = jTable1.getValueAt(row, COL.TIME.ordinal()).toString(); + String sTestHelp = String.valueOf(jTable1.getValueAt(row, COL.TESTHELP.ordinal())); + HashMap mParameters = getTestParameters(sTestPath); + //create map for passing details to Details Panel + HashMap details = new HashMap(); + details.put("deviceName", sDeviceName); + details.put("deviceDescription", sDeviceDescription); + details.put("testDescription", sTestDescription); + details.put("testSuite", sTestCaseName); + details.put("testName", sTestName); + details.put("testResult", sLastResult); + details.put("time", sResultTime); + details.put("parameters", mParameters); + details.put("testHelp", sTestHelp); + details.put("testPath", sTestPath); + //open details panel + JDialog dlg = new JDialog(getView(), "Test Details - " + sTestName, true); + //create a class to visualise the details panel + Class testingListDetailsClass = getController().getClassByName("TestingListDetails"); + JPanel detailsPanel = (JPanel) testingListDetailsClass.getConstructor(new Class[]{HashMap.class}).newInstance(new Object[]{details}); + + dlg.getContentPane().add(detailsPanel); + //dlg.add(new TestingListDetails()); + dlg.pack(); + dlg.setVisible(true); + } + + /** + * open details of the selected row in a new panel + * + * @throws exception + */ + private void openListEditor() throws Exception { + + JDialog dlg = new JDialog(getView(), "Add/remove tests", true); + //create a class to visualise the edit panel + Class editTestingListClass = getController().getClassByName("EditTestingList"); + JPanel detailsPanel = (JPanel) editTestingListClass.getConstructor(new Class[]{TableModel.class}).newInstance(jTable1.getModel()); + + dlg.getContentPane().add(detailsPanel); + //dlg.add(new TestingListDetails()); + dlg.pack(); + dlg.setVisible(true); + } + + /** + * put the test result in table + * + * @param deviceName name of the device to search in table + * @param testPath path of the test to search in table + * @param res String result returned by the test + * @param status String status returned by the test + * @return int index of the row of the device in table + */ + public int showResult(String deviceName, String testPath, String res, String status) { + int rowD = -1; + testPath = testPath.replace("\\\\", "\\"); + String sTestName = testPath; + //getController().getDataManager().appendLog(str(log)); + + //System.out.println("Looking for: deviceName: " + deviceName + "; testPath: " + testPath + " in table."); + + String sStatus; + if (status == "true") { + sStatus = TestStatus.SUCCESS.toString(); + } else if (status == "false") { + sStatus = TestStatus.FAILURE.toString(); + } else { + sStatus = status; + } + //search for device name in table + for (int row = 0; row <= jTable1.getRowCount() - 1; row++) { + if (deviceName.equals(jTable1.getValueAt(row, COL.DEVICENAME.ordinal())) + && testPath.equals(jTable1.getValueAt(row, COL.TESTPATH.ordinal()))) { + rowD = row; + sTestName = jTable1.getValueAt(rowD, COL.TESTNAME.ordinal()).toString(); + break; + } + } + ImageIcon icon = new ImageIcon(); + switch (sStatus) { + case "Success": + icon = TestStatus.SUCCESS.Icon(); + logger.log(Level.INFO, sStatus + " - Device: " + deviceName + "; Test: " + sTestName + "; Result: " + res); + log("INFO - " + sStatus + " - Device: " + deviceName + "; Test: " + sTestName + "; Result: " + res); + break; + case "Failure": + icon = TestStatus.FAILURE.Icon(); + logger.log(Level.SEVERE, sStatus + " - Device: " + deviceName + "; Test: " + sTestName + "; Result: " + res); + break; + case "Running": + icon = TestStatus.RUNNING.Icon(); + //logger.log(Level.INFO, "Running Test: " + sTestName + "."); + break; + } + if (rowD >= 0) { + jTable1.setValueAt(icon, rowD, COL.ICON.ordinal()); + jTable1.setValueAt(getNow(), rowD, COL.TIME.ordinal()); + jTable1.setValueAt(res, rowD, COL.RESULT.ordinal()); + jTable1.setValueAt(sStatus, rowD, COL.STATUS.ordinal()); + } else { + logger.log(Level.SEVERE, "Cant find Test: " + testPath + " in table."); + } + //check if there are still pending tests. If not, set the status of the tool to Stopped. + if (pendingTestsCount() == 0 && runningTestsCount() == 0) { + setToStopped(); + } + return rowD; + } + + /** + * return the amount of tests currently in Pending state + * + * @return int counter of pending tests + */ + public int pendingTestsCount() { + return testsStatusCount(TestStatus.PENDING); + } + + /** + * return the amount of tests currently in Running state + * + * @return int counter of running tests + */ + public int runningTestsCount() { + return testsStatusCount(TestStatus.RUNNING); + } + + /** + * return the amount of tests currently in Success state + * + * @return int counter of successful tests + */ + public int successTestsCount() { + return testsStatusCount(TestStatus.SUCCESS); + } + + /** + * returns the amount of tests currently in "status" state + * + * @param status type of status to count + * @return int counter with occurrences of the status + */ + private int testsStatusCount(TestStatus status) { + String sStatus; + boolean bSelected; + int iPendingTestsCount = 0; + for (int row = 0; row < jTable1.getRowCount(); row++) { + bSelected = (boolean) jTable1.getValueAt(row, COL.CHECK.ordinal()); + sStatus = jTable1.getValueAt(row, COL.STATUS.ordinal()).toString(); + if (bSelected && sStatus == status.toString()) { + iPendingTestsCount++; + } + } + return iPendingTestsCount; + } + + /** + * set the tests to stopped + */ + private void setToStopped() { + //No more tests to play. Stop + setButtonToStop(); + logger.log(Level.INFO, "End of tests."); + } + + /** + * get the first test currently in progress + * + * @return properties of the test in progress: {deviceName,testPath} + */ + public String[] getTestInProgress() { + String[] dsTestProperties = {"", ""}; + //search for device name in table + try { + for (int row = 0; row <= jTable1.getRowCount() - 1; row++) { + if (jTable1.getValueAt(row, COL.STATUS.ordinal()).toString().equals(TestStatus.RUNNING.toString())) { + dsTestProperties[0] = jTable1.getValueAt(row, COL.DEVICENAME.ordinal()).toString(); + dsTestProperties[1] = jTable1.getValueAt(row, COL.TESTPATH.ordinal()).toString(); + break; + } + } + } catch (Exception ex) { + this.setToStopped(); + SwingUtils.showMessage(this, "getTestInProgress()", ex.toString()); + } finally { + return dsTestProperties; + } + } + + /** + * Stop all the tests in progress and return to idle state (no further tests are launched) + * + * @param resultMessage the message that will be shown as Result of each stopped test + */ + public void stopAll(String resultMessage){ + setToStopped(); + String testInProgress[] = getTestInProgress(); + while(testInProgress[0]!=""){ + testInProgress = getTestInProgress(); + showResult(testInProgress[0], testInProgress[1], resultMessage, "false"); + } + try { + Object ret = eval("log('Tests interrupted by user')"); + } catch (Exception ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } + } + + /** + * return the status of the specified test name for specified device name + * + * @param deviceName name of the device + * @param testPath path of the test file + * @return String containing the result returned by the test + */ + public String getResult(String deviceName, String testPath) { + String sStatus = ""; + int rowD = -1, colT = -1; + //search for device name in table + for (int row = 0; row <= jTable1.getRowCount() - 1; row++) { + if (deviceName.equals(jTable1.getValueAt(row, COL.DEVICENAME.ordinal()))) { + rowD = row; + break; + } + } + if (rowD >= 0) { + //search for test in table + if (testPath.equals(jTable1.getValueAt(rowD, COL.TESTPATH.ordinal()))) { + colT = COL.TESTNAME.ordinal(); + } + } + //get the test result + if (colT >= 0 && rowD >= 0) { + sStatus = jTable1.getValueAt(rowD, COL.STATUS.ordinal()).toString(); + } + return sStatus; + } + + /** + * visualise test status (columns status and icon) + */ + public void updateStatus() { + String sStatus; + boolean bSelected; + ImageIcon icon = null; + String sStart; + for (int row = 0; row <= jTable1.getRowCount() - 1; row++) { + bSelected = (boolean) jTable1.getValueAt(row, COL.CHECK.ordinal()); + sStart = String.valueOf(jTable1.getValueAt(row, COL.STARTSEQUENCE.ordinal())); + if (bSelected) { + sStatus = TestStatus.PENDING.toString(); + icon = TestStatus.PENDING.Icon(); + if (sStart == "") { + sStart = StartSequence.AFTER.toString(); + } + } else { + sStatus = TestStatus.DISABLED.toString(); + icon = TestStatus.DISABLED.Icon(); + sStart = ""; + } + jTable1.setValueAt(bSelected, row, COL.CHECK.ordinal()); + jTable1.setValueAt(icon, row, COL.ICON.ordinal()); + jTable1.setValueAt(sStatus, row, COL.STATUS.ordinal()); + jTable1.setValueAt(sStart, row, COL.STARTSEQUENCE.ordinal()); + } + } + + /** + * launch the execution of the tests + */ + public void executeTests() { + RunTest runTest = new RunTest(); + Thread t = new Thread(runTest); + t.start(); + } + + /** + * tests run multithreaded + */ + public class RunTest implements Runnable { + + private HashMap mParameters; + //private HashMap args; + private HashMap hTests; + + /** + * + */ + public RunTest() { + //System.out.println("A0"); + } + + public void run() { + // code in the other thread, can reference "var" variable + executeTest(0); + } + + /** + * execute the selected tests in the list, starting from the position + * + * @param position row number from which to start executing tests + */ + private void executeTest(int position) { + boolean bSelected = false; + String sStartSequence, sStatus; + int[] selectedTestsRows = {}; + //scan through the table starting from 'position' and execute the first selected test found + int row = 0;// position; + if (row >= 0 && row < jTable1.getRowCount()) { + for (row = position; row < jTable1.getRowCount(); row++) { + bSelected = (boolean) jTable1.getValueAt(row, COL.CHECK.ordinal()); + sStartSequence = jTable1.getValueAt(row, COL.STARTSEQUENCE.ordinal()).toString(); + sStatus = jTable1.getValueAt(row, COL.STATUS.ordinal()).toString(); + //collect tests to be launched in parallel + //the test must be: selected, set as start with previous, pending. + //alternatively, the test must be: selected, first of the list. + //System.out.println(String.valueOf(row) + "\t" + String.valueOf(bSelected) + "\t" + String.valueOf(selectedTestsRows.length) + "\t" + sStartSequence + "\t" + sStatus); + if (bSelected + && sStatus.equals(TestStatus.PENDING.toString()) + && (selectedTestsRows.length == 0 || //the test must be: selected, pending, first of the list. + sStartSequence.equals(StartSequence.TOGETHER.toString()))) { //or the test must be: selected, pending, set as start with previous + selectedTestsRows = append(selectedTestsRows, row); + } else if (bSelected + && sStatus.equals(TestStatus.PENDING.toString()) &&//if this test must be executed... + selectedTestsRows.length > 0 && //but there are already tests to be executed in parallel.... + (sStartSequence.equals(StartSequence.AFTER.toString()))) { //...and this test must be executed in series, then stop searching + break; + } + } + //if the user pressed Stop, or error, exit from run: + if(!isTestRunAllowed()) + return; + if (selectedTestsRows.length > 0) { //at least one test is selected: launch it (or them) + System.out.println("\n===================================================\n"); + executeParallelTestsGroup(selectedTestsRows); //last execution did not find a test file. Continue with next execution + executeTest(position + 1); + } else {//no tests were selected. end. + setToStopped(); + } + } + } + + /** + * build a HashMap containing the items picked from a specific table row. + * + * @param row the row whose items will fill the HashMap + * @return the HashMap containing the items picked from the specified table row. + */ + private HashMap buildMapFromTableRow(int row) { + String sDeviceName = jTable1.getValueAt(row, COL.DEVICENAME.ordinal()).toString(); + String sTestName = jTable1.getValueAt(row, COL.TESTNAME.ordinal()).toString(); + String sTestCaseName = jTable1.getValueAt(row, COL.TESTSUITE.ordinal()).toString(); + String sTestPath = jTable1.getValueAt(row, COL.TESTPATH.ordinal()).toString(); +// HashMap mParameters = buildParametersMap(String.valueOf(jTable1.getValueAt(row, COL.TESTPARAMS.ordinal()))); + //get the parameters directly frm he config file + HashMap mParameters = getTestParameters(sTestPath); + HashMap testArgs = new HashMap(); + //args.put("ret", ""); + testArgs.put(testArgNames.PARAMETERS.toString(), mParameters); + testArgs.put(testArgNames.TEST.toString(), sTestName); + testArgs.put(testArgNames.DEVICE.toString(), sDeviceName); + testArgs.put(testArgNames.TEST_PATH.toString(), sTestPath); + testArgs.put(testArgNames.STATUS.toString(), false); + + return testArgs; + } + + /** + * convert HashMap string separators to python dictionary string + * separators + * + * @param sParameters string coming from HashMap conaining the list of + * parameters to be passed to the test script. Example: + * {repeatTimes={description=Repeat N times, value=1}, + * midPoint={description=Middle point A, value=41.0}, + * spanFromMidPoint={description=B steps around middle point A, + * value=2.0}} + * @return string of dictionary in python syntax. This can be passed to + * the python test script. Example of output: + * {'repeatTimes':{'description':'Repeat N + * times','value':'1'},'midPoint':{'description':'Middle point + * A','value':'41.0'},'spanFromMidPoint':{'description':'B steps around + * middle point A','value':'2.0'} + */ + private String convertParametersMapToPythonMap(String sParameters) { + String sPythonParams = sParameters; + sPythonParams = sPythonParams.replace(", ", ","); + sPythonParams = sPythonParams.replace(" ,", ","); + sPythonParams = sPythonParams.replace("{{", "#@"); + sPythonParams = sPythonParams.replace("}}", "@#"); + sPythonParams = sPythonParams.replace("},", "@%#"); + sPythonParams = sPythonParams.replace(",{", "#%@"); + sPythonParams = sPythonParams.replace("={", "^%&"); + sPythonParams = sPythonParams.replace("=}", "&%^"); + sPythonParams = sPythonParams.replace(",", "','"); + sPythonParams = sPythonParams.replace("{", "{'"); + sPythonParams = sPythonParams.replace("}", "'}"); + sPythonParams = sPythonParams.replace("=", "':'"); + sPythonParams = sPythonParams.replace("^%&", "':{'"); + sPythonParams = sPythonParams.replace("&%^", "'}:'"); + sPythonParams = sPythonParams.replace("#@", "{{'"); + sPythonParams = sPythonParams.replace("@#", "'}}"); + sPythonParams = sPythonParams.replace("@%#", "'},'"); + sPythonParams = sPythonParams.replace("#%@", "',{'"); + return sPythonParams; + } + + /** + * start all the tests in the array rowsToExecute. all tests in the + * listed row indexes will be started at the same time. + * + * @param rowsToExecute array of indexes relative to the test rows in + * the table. The indexes in the array will execute the test in + * corresponding row + * @return return value: 0 means ok, <0 means problem + */ + private int executeParallelTestsGroup(int[] rowsToExecute) { + int iRet = -1; + HashMap args2 = new HashMap(); //this is the global map that will contain one map per test. + HashMap testArgs; //this is the map for a test. + RunTest runTest; + String sTestName = "", sDeviceName = "", sTestPath = ""; + for (int row : rowsToExecute) { + //System.out.println(String.valueOf(row) + "\t" + sDeviceName + "\t" + sTestName + "\t" + sTestCaseName + "\t" + String.valueOf(rowsToExecute.length)); + try { + testArgs = buildMapFromTableRow(row); + sTestName = (String) testArgs.get(testArgNames.TEST.toString()); + sTestPath = (String) testArgs.get(testArgNames.TEST_PATH.toString()); + sDeviceName = (String) testArgs.get(testArgNames.DEVICE.toString()); + mParameters = (HashMap) testArgs.get(testArgNames.PARAMETERS.toString()); + File f = new File(sTestPath); + if (!f.exists() || f.isDirectory()) { + logger.log(Level.SEVERE, "Cannot find test script: " + sTestPath); + showResult(sDeviceName, sTestPath, "Cannot find test script: " + sTestPath, TestStatus.FAILURE.toString()); + hTests = args2; + continue; + } + //if the user pressed Stop, exit from run: + if(!isTestRunAllowed()) + return iRet; + showResult(sDeviceName, sTestPath, "Test running", TestStatus.RUNNING.toString()); + //launch the test + if (!mParameters.isEmpty()) { + logger.log(Level.INFO, "Running test '" + sTestName + "' with the following parameters: " + mParameters.toString()); + System.out.println("Running test '" + sTestName + "' with the following parameters: " + mParameters.toString()); + } else { + logger.log(Level.INFO, "Running Test '" + sTestName + "'. No parameters found."); + System.out.println("Running test '" + sTestName + "'. No parameters found."); + } + args2.put(sTestPath, testArgs); + hTests = args2; + iRet = 0; + } catch (Exception ex) { + SwingUtils.showMessage(TestingList.this, "executeTest()", ex.toString()); + logger.log(Level.SEVERE, ex.toString()); + showResult(sDeviceName, sTestPath, ex.toString(), TestStatus.FAILURE.toString()); + setToStopped(); + } + } + try { + int iLastExecutedTestIndex = -1; + final String sParallelizeBegin = "(run,(str('"; + final String sParallelizeEnd = "'),))"; + String sParallelizeArguments; + try { + //System.out.println("A0.1"); + String sParallelizeCommand = "parallelize("; + int i = 0; + int iTotalEntries = hTests.entrySet().size(); + HashMap args = new HashMap(); + System.out.println("hTests: "+hTests.entrySet().toString()); + if(hTests.isEmpty()) return iRet; + for (Map.Entry hTest : hTests.entrySet()) { + sTestPath = hTest.getKey().toString(); + sTestPath = sTestPath.replace("\\", "\\\\"); + sParallelizeCommand = sParallelizeCommand + "(run,(str('" + sTestPath; + sParallelizeArguments = "None, {'parameters':" + convertParametersMapToPythonMap(hTest.getValue().get("parameters").toString()) + + ",'test':'" + hTest.getValue().get(testArgNames.TEST.toString()) + + "','device':'" + hTest.getValue().get(testArgNames.DEVICE.toString()) + + "','status':'" + hTest.getValue().get(testArgNames.STATUS.toString()) + "'}"; + sParallelizeCommand = sParallelizeCommand + "')," + sParallelizeArguments; + i++; + if (i < iTotalEntries) { + sParallelizeCommand = sParallelizeCommand + ")),"; //between each "run" command + } else { + sParallelizeCommand = sParallelizeCommand + ")))"; //very last part of command "parallelize" + } + } + System.out.println(sParallelizeCommand); + Object ret = eval(sParallelizeCommand); + System.out.println(ret); + String sTestResult, sTestStatus; + if(ret == null){ + SwingUtils.showMessage(TestingList.this, "executeParallelTestsGroup()", "The test script(s) did not return any feedback."); + System.out.println("The test script(s) did not return any feedback."); + } + //scan through all return mappings of all run tests + for (Object oTestRet : (ArrayList) ret) { + //check if the mapping of the selected test has all expected return values + if (((List) oTestRet).size() >= 4) { + //extract return data of the current test + sTestPath = String.valueOf(((List) oTestRet).get(0)); + sDeviceName = String.valueOf(((List) oTestRet).get(1)); + sTestResult = String.valueOf(((List) oTestRet).get(2)); + sTestStatus = String.valueOf(((List) oTestRet).get(3)); + //from the map of executed tests, get the test name (key is test path) + HashMap hTest = hTests.get(sTestPath); + sTestName = String.valueOf(hTest.get(testArgNames.TEST.toString())); + } else { //problem, the test script does not return all the expected return values + String sErrorText = "Test " + sTestPath + " did not return all required return values"; + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, sErrorText); + SwingUtils.showMessage(TestingList.this, "executeParallelTestsGroup()", sErrorText); + System.out.println(String.valueOf(sErrorText)); + //try to fetch at least first element of returned map. If fails, it will go to catch + sTestPath = String.valueOf(((List) oTestRet).get(0)); + sTestStatus = sErrorText; + sTestResult = "false"; + HashMap hTest = hTests.get(sTestPath); + sDeviceName = String.valueOf(hTest.get(testArgNames.DEVICE.toString())); + sTestName = String.valueOf(hTest.get(testArgNames.TEST.toString())); + } + System.out.println("Result: " + sDeviceName + "|" + sTestPath + "|" + sTestResult + "|" + sTestStatus); + iLastExecutedTestIndex = showResult(sDeviceName, sTestPath, sTestResult, sTestStatus); + } + } catch (StatementException intEx) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, intEx); + System.out.println("User interrupted test! |"+ sDeviceName+"|"+ sTestPath+"|"+ String.valueOf(intEx)); + stopAll("Test stopped by user"); + //showResult(sDeviceName, sTestPath, "User interrupted test", "false"); + //setToStopped(); + } catch (ClassCastException ccex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ccex); + SwingUtils.showMessage(TestingList.this, "executeParallelTestsGroup()", ccex.toString()); + //System.out.println(String.valueOf(ccex)); + if (!sDeviceName.isEmpty()) { + showResult(sDeviceName, sTestPath, ccex.toString(), TestStatus.FAILURE.toString()); + } + }catch (Exception ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + SwingUtils.showMessage(TestingList.this, "executeParallelTestsGroup()", ex.toString()); + System.out.println(String.valueOf(ex)); + showResult(sDeviceName, sTestPath, ex.toString(), TestStatus.FAILURE.toString()); + } + } catch (Exception ex) { + SwingUtils.showMessage(TestingList.this, "executeParallelTestsGroup(), run thread", ex.toString()); + logger.log(Level.SEVERE, ex.toString()); + setToStopped(); + } + return iRet; + } + } + + /** + * table management (hide internal columns, size, etc) + */ + private void buildTable() { + String sDate = getNow(); + DefaultTableModel model = (DefaultTableModel) jTable1.getModel(); + jTable1.setModel(model); + + //Set up the combo box editor for the Start Sequence cells. + JComboBox comboBox = new JComboBox(); + comboBox.addItem(StartSequence.AFTER.toString()); + comboBox.addItem(StartSequence.TOGETHER.toString()); + jTable1.getColumnModel().getColumn(COL.STARTSEQUENCE.ordinal()).setCellEditor(new DefaultCellEditor(comboBox)); + //Set up tool tips for the sequence cells. + DefaultTableCellRenderer renderer = new DefaultTableCellRenderer(); + renderer.setToolTipText("Click for options"); + jTable1.getColumnModel().getColumn(COL.STARTSEQUENCE.ordinal()).setCellRenderer(renderer); + + jTable1.getColumnModel().getColumn(COL.STARTSEQUENCE.ordinal()).setPreferredWidth(30); + jTable1.getColumnModel().getColumn(COL.ICON.ordinal()).setMaxWidth(27); + jTable1.getColumnModel().getColumn(COL.CHECK.ordinal()).setMaxWidth(27); + jTable1.getColumnModel().getColumn(COL.DEVICENAME.ordinal()).setPreferredWidth(30); + jTable1.getColumnModel().getColumn(COL.STATUS.ordinal()).setPreferredWidth(20); + hideColumn(COL.DEVICEDESCR); + hideColumn(COL.TESTPATH); + hideColumn(COL.TESTDESCR); + hideColumn(COL.TESTPARAMS); + hideColumn(COL.TESTHELP); + jTable1.setAutoCreateRowSorter(true); + updateStatus(); + } + + private void hideColumn(COL column) { + jTable1.getColumnModel().getColumn(column.ordinal()).setMinWidth(0); + jTable1.getColumnModel().getColumn(column.ordinal()).setMaxWidth(0); + } + + /** + * append test info (see parameters) to table + * + * @param deviceName + * @param deviceDescription + * @param testSuite + * @param testName + * @param testParams string of parameters. See buildParametersMap() for + * details + * @param testDescription + * @param testHelp + * + */ + private void addToTable(String deviceName, + String deviceDescription, + String testSuite, + String testName, + String testParams, + String testDescription, + String testHelp) { + String sDate = ""; + if (testName.equals("") || deviceName.equals("")) { + return; + } + try { + ImageIcon icon = null;// new ImageIcon(getClass().getResource("/icons/button_pause-16px.png")); + DefaultTableModel model = (DefaultTableModel) jTable1.getModel(); + //String testPath = FilenameUtils.separatorsToSystem(TESTS_TESTS_DEFAULT_DIR + testSuite + "/" + testName + "/" + testName + ".py"); + String testPath = Paths.get(TESTS_TESTS_DEFAULT_DIR.toString(), testSuite, testName, testName + ".py").toString(); + Object rowData[] = new Object[]{false, "", sDate, deviceName, deviceDescription, testSuite, testName, testPath, testParams, testDescription, testHelp, "", "Pending", icon}; + //vedify that this test is not already in the table + int totalRows = model.getRowCount(); + boolean bTestAlreadyInTable = false; + for (int row = 0; row < totalRows; row++) { + bTestAlreadyInTable = (model.getValueAt(row, COL.DEVICENAME.ordinal()).toString().equals(deviceName) + && model.getValueAt(row, COL.TESTSUITE.ordinal()).toString().equals(testSuite) + && model.getValueAt(row, COL.TESTNAME.ordinal()).toString().equals(testName) + && model.getValueAt(row, COL.TESTPATH.ordinal()).toString().equals(testPath)); + if (bTestAlreadyInTable) { + break; + } + } + if (!bTestAlreadyInTable) { + model.addRow(rowData); + } + } catch (Exception ex) { + ex.printStackTrace(); + SwingUtils.showMessage(this, "loadSettings()", ex.toString()); + } + updateStatus(); + } + + /** + * get the current time in format like 2015/07/02 15:59:43 + * + * @return formatted time + */ + public String getNow() { + DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"); + Date date = new Date(); + return dateFormat.format(date); + } + + /** + * get the current time in format like 20150702155943 + * + * @return time with sortable format + */ + public String getnow() { + DateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss"); + Date date = new Date(); + return dateFormat.format(date); + } + + /** + * scan tests directory, scan devices directory, search for their test cases + * and scan for tests. + * + * @throws FileNotFoundException + * @throws IOException + */ + public void loadTests() throws FileNotFoundException, IOException { + Properties propDevice = new Properties(); + Properties propTest = new Properties(); + //String fileName = TESTS_DEVICES_DEFAULT_DIR; + //File folder = new File(fileName); + File testsFolder = null; + String sTestName; + int iCounter = 0; + //search devices and their tests + //Scan the list of devices + File[] listOfDevices = TESTS_DEVICES_DEFAULT_DIR.toFile().listFiles(); + for (File deviceInList : listOfDevices) { + propDevice.clear(); + if (deviceInList.isFile()) { + } else if (deviceInList.isDirectory()) { + File configFile = new File(deviceInList.getPath() + FilenameUtils.separatorsToSystem("/" + TESTS_CONFIG_FILENAME)); + if (configFile.exists() && !configFile.isDirectory()) { + InputStream is = new FileInputStream(configFile); + propDevice.load(is); + is.close(); + //config of device was loaded. now load the config of each test belonging to the device + testsFolder = Paths.get(TESTS_TESTS_DEFAULT_DIR.toString(), propDevice.getProperty("tests")).toFile(); + if (testsFolder.exists() && testsFolder.isDirectory()) { + File[] listOfTests = testsFolder.listFiles(); + for (File testinList : listOfTests) { + propTest.clear(); + if (testinList.isDirectory()) { + configFile = new File(testinList.getPath() + FilenameUtils.separatorsToSystem("/" + TESTS_CONFIG_FILENAME)); + if (configFile.exists() && !configFile.isDirectory()) { + InputStream ist = new FileInputStream(configFile); + propTest.load(ist); + ist.close(); + addToTable(propDevice.getProperty("name"), + propDevice.getProperty("description"), + propDevice.getProperty("tests"), + propTest.getProperty("name"), + "", //test parameters + "", //test description + propTest.getProperty("help")); + iCounter++; + } + } + } + } + } + } + } + showSelectedTestsOnly(jCheckBoxMenuShowSelectedTests1.getState()); + logger.log(Level.INFO, iCounter + " tests loaded."); + } + + /** + * scan tests table and see if tests/devices in the table still exist in directory. + * Remove from table the tests whose files do not exist in directories. + * + * @throws FileNotFoundException + * @throws IOException + */ + public void cleanTests() throws FileNotFoundException, IOException { + Properties propDevice = new Properties(); + Properties propTest = new Properties(); + //String fileName = TESTS_DEVICES_DEFAULT_DIR; + //File folder = new File(fileName); + File testsFolder = null; + String sTestName; + int iCounter = 0; + //search devices and their tests + //Scan the list of devices + File[] listOfDevices = TESTS_DEVICES_DEFAULT_DIR.toFile().listFiles(); + //collect all tests from files + List testsInDir = new ArrayList(); + List testDetails = new ArrayList(); + for (File deviceInList : listOfDevices) { + propDevice.clear(); + if (deviceInList.isDirectory()) { + File configFile = new File(deviceInList.getPath() + FilenameUtils.separatorsToSystem("/"+TESTS_CONFIG_FILENAME)); + if (configFile.exists() && !configFile.isDirectory()) { + InputStream is = new FileInputStream(configFile); + propDevice.load(is); + is.close(); + //config of device was loaded. now load the config of each test belonging to the device + testsFolder = Paths.get(TESTS_TESTS_DEFAULT_DIR.toString(), propDevice.getProperty("tests")).toFile(); + if (testsFolder.exists() && testsFolder.isDirectory()) { + File[] listOfTests = testsFolder.listFiles(); + for (File testinList : listOfTests) { + propTest.clear(); + if (testinList.isDirectory()) { + configFile = new File(testinList.getPath() + FilenameUtils.separatorsToSystem("/"+TESTS_CONFIG_FILENAME)); + if (configFile.exists() && !configFile.isDirectory()) { + InputStream ist = new FileInputStream(configFile); + propTest.load(ist); + ist.close(); + testDetails = new ArrayList(); + testDetails.add(propDevice.getProperty("name")); + testDetails.add(propDevice.getProperty("tests")); + testDetails.add(propTest.getProperty("name")); + iCounter++; + testsInDir.add(testDetails); + } + } + } + } + } + } + } + //now check each test in table, if it is present in directory + DefaultTableModel model = (DefaultTableModel) jTable1.getModel(); + int row; + boolean bTestAlreadyInTable = false; + String testSuiteTable, testSuiteDir; + String testNameTable, testNameDir; + String deviceNameTable, deviceNameDir; + String testPathTable, testPathDir; + int totalRows = model.getRowCount(); + //loop among the tests in the table + for (row = 0; row < totalRows; row++) { + bTestAlreadyInTable = false; + deviceNameTable = model.getValueAt(row, COL.DEVICENAME.ordinal()).toString(); + //testSuiteTable = model.getValueAt(row, COL.TESTSUITE.ordinal()).toString(); + //testNameTable = model.getValueAt(row, COL.TESTNAME.ordinal()).toString(); + testPathTable = model.getValueAt(row, COL.TESTPATH.ordinal()).toString(); + //loop to compare current test in table with all tests in directory + for (int i = 0; i < testsInDir.size(); i++) { + deviceNameDir = testsInDir.get(i).get(0).toString(); + testSuiteDir = testsInDir.get(i).get(1).toString(); + testNameDir = testsInDir.get(i).get(2).toString(); + testPathDir = Paths.get(TESTS_TESTS_DEFAULT_DIR.toString(), + testSuiteDir, testNameDir, testNameDir + ".py").toString(); + //check if the test files and device files corresponding to the current test row exist + bTestAlreadyInTable = (testPathDir.equals(testPathTable) && deviceNameDir.equals(deviceNameTable)); + if (bTestAlreadyInTable) { + break; + } + } + if (!bTestAlreadyInTable) { + //this test in table does not exist any more in the tests directory or in the device directory: remove + model.removeRow(row); + totalRows = model.getRowCount(); + row=0; + } + } + } + + /** + * Build a map with optional parameters to be passed to the testing script. + * The map is like this: parameters \_ name | \_ value | \_ description \_ + * name | \_ value | \_ description ... the name 'name' is the mapping key. + * 'value' and 'description' are constant mapping keys of a nested map. + * + * @param parametersString string containing the parameters. Syntax: + * name:value:description[;name:value:description;...] + */ + private HashMap buildParametersMap(String parametersString) { + HashMap mParameters = new HashMap(); // contains name and attributes + HashMap mParameterAttributes = new HashMap(); //contians value and description + String[] dsParameterAttributes = null; + String[] dsParameters = parametersString.split(";"); + for (String sParameter : dsParameters) { + dsParameterAttributes = sParameter.split(":"); + if (dsParameterAttributes.length > 2) { + mParameterAttributes = new HashMap(); + mParameterAttributes.put("value", (Object) dsParameterAttributes[1]); + mParameterAttributes.put("description", dsParameterAttributes[2]); + //add parameter name and attributes (value + description) + mParameters.put(dsParameterAttributes[0], mParameterAttributes); + } + } + return mParameters; + } + + /** + * get the parameters from the test config file + * + * @param sTestPath directory where the test files are (directory with the + * test name) + * @return HashMap of the test parameters. See buildParametersMap() for + * details. + */ + private HashMap getTestParameters(String sTestPath) { + String testParams = getConfigItem("parameters", sTestPath); + return buildParametersMap(testParams); + } + + /** + * Get the description of the test. + * + * @param sTestPath directory where the test files are (directory with the + * test name) + * @return test description + */ + private String getTestDescription(String sTestPath) { + return getConfigItem("description", sTestPath); + } + + /** + * generic function that get a configuration item of a test. + * + * @param sParameterName configuration item name to retrieve from the test + * @param sTestPath directory where the test files are (directory with the + * test name) + * @return value of the configuration item + */ + private String getConfigItem(String sParameterName, String sTestPath) { + Properties propTest = new Properties(); + File fileTest = new File(sTestPath); + File dirTest = fileTest.getParentFile(); + String testParams = ""; + if (dirTest.isDirectory()) { + File configFile = new File(dirTest.getPath() + FilenameUtils.separatorsToSystem("/"+TESTS_CONFIG_FILENAME)); + if (configFile.exists() && !configFile.isDirectory()) { + try { + InputStream ist = new FileInputStream(configFile); + propTest.load(ist); + ist.close(); + testParams = propTest.getProperty(sParameterName); + if (testParams == null) { + testParams = ""; + } + + } catch (IOException ex) { + Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex); + } + } + } + return testParams; + } + + /** + * Save current setup in a file. The current position of table rows is also + * saved. + */ + public void saveSettings() { + if (!TESTS_CONFIG_DEFAULT_DIR.toFile().isDirectory()) { + boolean success = TESTS_CONFIG_DEFAULT_DIR.toFile().mkdirs(); + if (!success) { + // Directory creation failed + SwingUtils.showMessage(this, "saveSettings()", "Cannot create directory " + TESTS_CONFIG_DEFAULT_DIR.toString()); + } + } + JFileChooser fc = new JFileChooser(TESTS_CONFIG_DEFAULT_DIR.toFile()); + int returnVal = fc.showSaveDialog(this); + if (returnVal == JFileChooser.APPROVE_OPTION) { + File file = fc.getSelectedFile(); + saveSettings(file); + } + } + + /** + * Save current setup in a file. The current position of table rows is also + * saved. + * + * @param file file containing the settings + */ + private void saveSettings(File file) { + DefaultTableModel tableModel = (DefaultTableModel) jTable1.getModel(); + try { + ObjectOutputStream out = new ObjectOutputStream( + new FileOutputStream(file)); + out.writeObject(tableModel.getDataVector()); + out.close(); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + /** + * Save current setup in a file. The current position of table rows is also + * saved. + */ + public void loadSettings() { + final JFileChooser fc = new JFileChooser(); + fc.setCurrentDirectory(TESTS_CONFIG_DEFAULT_DIR.toFile()); + int returnVal = fc.showOpenDialog(this); + if (returnVal == JFileChooser.APPROVE_OPTION) { + File file = fc.getSelectedFile(); + loadSettings(file); + jCheckBoxMenuShowSelectedTests.setSelected(true); + this.showSelectedTestsOnly(true); + } + } + + /** + * Load current setup from a file. The current position of table rows is + * also saved. + * + * @param file file containing the settings + */ + private void loadSettings(File file) { + DefaultTableModel tableModel = (DefaultTableModel) jTable1.getModel(); + try { + ObjectInputStream in = new ObjectInputStream(new FileInputStream(file)); + Vector rowData = (Vector) in.readObject(); + Iterator itr = rowData.iterator(); + //clear table + tableModel.getDataVector().removeAllElements(); + tableModel.fireTableDataChanged(); + //rewrite table + while (itr.hasNext()) { + tableModel.addRow((Vector) itr.next()); + } + in.close(); + loadTests(); + } catch (Exception ex) { + ex.printStackTrace(); + SwingUtils.showMessage(this, "loadSettings()", ex.toString()); + } + } + + +}